programming/4_Python_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tcdZsU48M34N"
   },
   "source": [
    "To open this notebook in Google Colab and start coding, click on the Colab icon below.\n",
    "\n",
    "<table style=\"border:2px solid orange\" align=\"left\">\n",
    "  <td style=\"border:2px solid orange \">\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/neuefische/ds-welcome-package/blob/main/programming/4_Python_Functions.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "    \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "psnfJw4QNy_3"
   },
   "source": [
    "---\n",
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GBuNHO69N107"
   },
   "source": [
    "Another little milestone on your way to become a Data Scientist is to learn how to write your own functions. \n",
    "But before we start dealing with functions let’s digress briefly into the world of **programming paradigms**. Programming paradigms are a way to classify programming languages based on their features like concepts, values and practices. Different paradigms often have varying ways of writing programs and thinking about them. There is a plethora of different paradigms and most languages can be classified into multiple of them. When you are new to programming you don’t have to worry much about those paradigms, but when you start to write complex programs or software it’s important to ponder and choose the one that best suits your needs. \n",
    "\n",
    "At this point we want to briefly introduce one paradigm called **procedural programming**, which is the one paradigm which most of the new programmers will (unconsciously) start with. In simple terms, procedural code is a concatenation of step-by-step instructions to tell the computer how to solve a specific task. When using procedural programming the code is divided into several procedures, also known as routines or **functions**, which will contain the single steps to be carried out. \n",
    "\n",
    "The first procedural programming languages appeared around 1960, including Fortran, ALGOL or BASIC.  Other programming languages you might have heard of which are considered to be procedural are Pascal and C, which were published in the early 1970s. Python supports procedural programming as well, but also other paradigms like for example **object-oriented programming**, which we will briefly introduce in another notebook. \n",
    "\n",
    "But enough theory for now, let’s start with the fun part. In this notebook you will learn...\n",
    "* what functions are \n",
    "* why you should use them \n",
    "* how to write your own functions \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pjkaTSBpPEoX"
   },
   "source": [
    "### What is a function and why is it useful? \n",
    "\n",
    "Functions in Python are a block of organized code which performs a specific task. Using functions has several advantages: \n",
    "\n",
    "* It will help you to reduce complex programs into smaller and better readable pieces.\n",
    "* Since you can call a function multiple times, it helps to avoid unnecessary repetitions of the same code. You can even reuse the same function in different projects. \n",
    "* A variable you define or change inside a function belongs to the *local scope* of the function and can only be used inside the function. You cannot use it outside of the function unless you explicitly define it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SMnzklgNhqte"
   },
   "source": [
    "### Built-in functions\n",
    "\n",
    "In the last notebooks we've actually seen a number of built-in functions. We've worked with the `print()` function, which outputs what is enclosed in the parentheses. We've also seen the `range()` function, which returns a list of numbers from an inputted minimum number to an inputted maximum number. `min()`, `max()` or `round()` are functions as well. There are many built-in functions available in Python. You can find an overview [here](https://docs.python.org/2/library/functions.html). Each of these functions is constructed in a similar way and in the following sections we want to learn how.\n",
    "\n",
    "Do you remember more built-in functions you've already used or seen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rSHy5VFCEVyU"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show examples.\n",
    "</summary>\n",
    "\n",
    "abs(), \n",
    "complex(), \n",
    "type(), \n",
    "int(), \n",
    "input()\n",
    "\n",
    "</detail>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8EfaTE4YSxU9"
   },
   "source": [
    "### Function syntax\n",
    "\n",
    "The general syntax of a function in Python looks like this:\n",
    "\n",
    "```\n",
    "def function_name():\n",
    "    <function_body>\n",
    "```\n",
    "\n",
    "We define a function by using the keyword `def` followed by a function name. You can choose whatever name you want but it should be meaningful and you should follow the *snake_case* naming convention (all lowercase letters separated by an underscore). The first line ends with parentheses `()`\n",
    "followed by a colon `:`. \n",
    "After the colon starts an indented code block which defines what our function will do. \n",
    "\n",
    "In the next cell we will define a simple function. To call the function we just need to type the function name followed by the parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dxH4ooHUMzyb"
   },
   "outputs": [],
   "source": [
    "# Defining a function\n",
    "def hello():\n",
    "    print(\"Welcome stranger!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_CjYjZ40WUxQ"
   },
   "outputs": [],
   "source": [
    "# Calling a function\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "APGrS_HuWlrP"
   },
   "source": [
    "### Arguments and parameters\n",
    "\n",
    "This is nice but yet not really useful. To make it more powerful we can pass information as arguments to our functions. Arguments are specified after the function name inside the parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hZb_wAuPWWWC"
   },
   "outputs": [],
   "source": [
    "# Defining function with one argument\n",
    "def hello_you(name):\n",
    "    print(\"Hello\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O1Y5F_P3Xso6"
   },
   "outputs": [],
   "source": [
    "# Change name to your name before running this cell \n",
    "hello_you(\"name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DprBeWoPwEp9"
   },
   "source": [
    "You will often read the term *parameter* as well. The terms *parameter* and *argument* can both be used for describing information passed to a function inside the parentheses. From a functions perspective a *parameter* is the variable listed inside the parentheses of the functions definition. An *argument* on the other hand is the value that is given to the function when it is called. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qLwduAXyyNfr"
   },
   "source": [
    "### Positional arguments\n",
    "\n",
    "You can add as many arguments as necessary separated by commas. By default, parameters have a positional behavior and you need to pass them to the function when you call it in the same order that they were defined.\n",
    "Therefore those arguments are called **positional arguments** since they are called by their position. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FlrLzpqMYVHG"
   },
   "outputs": [],
   "source": [
    "# Defining function with two arguments \n",
    "def welcome_at_neuefische(location, bootcamp):\n",
    "    print(\"Welcome at neuefische to the\", bootcamp, \"bootcamp in\", location, \"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AFXryxBKYU_p"
   },
   "outputs": [],
   "source": [
    "# Calling function with two arguments\n",
    "welcome_at_neuefische(\"Hamburg\", \"Data Science\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wfo8FJvcMGQb"
   },
   "source": [
    "In the next cell call the function `welcome_at_neuefische` again but this time change the order of the arguments. Do you see what happend?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Btv_f9CSgxuA"
   },
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JNl5rb_3x_jk"
   },
   "source": [
    "### Keyword arguments\n",
    "\n",
    "You can also pass **keyword arguments** to a function. In this case the order does not matter. The general syntax for this is `key = value`.\n",
    "\n",
    "> Note that you will often find the abbreviations `args` for *arguments* and `kwargs` for *keyword arguments* in Python documentations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1V6UEmVRg8jC"
   },
   "outputs": [],
   "source": [
    "# Calling the welcome_at_neuefische function from above with keyword arguments\n",
    "welcome_at_neuefische(location=\"Cologne\", bootcamp=\"Web Development\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FHMGgWj7Mp4m"
   },
   "outputs": [],
   "source": [
    "# Changing their order does not affect the output\n",
    "welcome_at_neuefische(bootcamp=\"Web Development\", location=\"Cologne\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WsKU1CPizejg"
   },
   "source": [
    "### Default parameter value\n",
    "\n",
    "You can choose a default value for any parameter when you define a function. In this case calling a function only requires the arguments for which you have no default values defined. \n",
    "\n",
    "If you choose a default value only for some of the arguments of a function you have to care about their order. Arguments with default values have to follow those without. Otherwise it will return an error. Let's have a look at an example to make this clearer.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YF1NT3pSAQAA"
   },
   "outputs": [],
   "source": [
    "# Correct order of arguments \n",
    "def neuefische_bootcamp(bootcamp, location='Hamburg'):\n",
    "    print(\"The\", bootcamp, \"bootcamp at neuefische in\", location, \"will be fun.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pZlr-ruCAP4w"
   },
   "outputs": [],
   "source": [
    "# Wrong order of arguments\n",
    "def neuefische_bootcamp(location=\"Hamburg\", bootcamp):\n",
    "    print(\"The\", bootcamp, \"bootcamp at neuefische in\", location, \"will be fun.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-vt4JR1EA9ie"
   },
   "source": [
    "The function `neuefische_bootcamp` has two parameters. `bootcamp` has no default value so it is required during a call. `location` on the other hand has a default value, so it is optional.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xWwopyaPz_2T"
   },
   "outputs": [],
   "source": [
    "# Calling the function without changing the default value of location\n",
    "neuefische_bootcamp(\"Data Science\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nVVJHXb60Tec"
   },
   "outputs": [],
   "source": [
    "# Calling the function with changing the default value of location\n",
    "neuefische_bootcamp(\"Data Science\", \"Cologne\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tAfGeCIS6Aa5"
   },
   "source": [
    "### Return values \n",
    "\n",
    "Most of the time you will not only want your functions to print something but rather return a value, data or something else. To achieve this you can use the `return` statement at the end of your function. \n",
    "\n",
    ">**Note:** Even if you define a variable called `number` inside the following function this variable will not exist outside. This is because the variable only exists in the *local scope* of the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "h0zgwEVJ6Dyf"
   },
   "outputs": [],
   "source": [
    "# Function returning the sum of two values\n",
    "def add_numbers(x, y):\n",
    "    number = x + y\n",
    "    return number\n",
    "\n",
    "# You can write the same function in two lines\n",
    "def add_numbers_2(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zFbS77RU8n9z"
   },
   "outputs": [],
   "source": [
    "add_numbers(35, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QgjrgfY280tK"
   },
   "outputs": [],
   "source": [
    "add_numbers_2(35, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will raise an error since the variable number only exists inside the function add_numbers \n",
    "number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q8GQeAIF9uY2"
   },
   "source": [
    "### Pass statement\n",
    "\n",
    "A function definition cannot be empty. This will always raise an error. If you nevertheless want to define an empty function you can use the `pass` statement to avoid raising an error. This might be helpful when you are in the middle of coding and haven't written the implementation of a function yet but want to do it in the future. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Gf2EcrKG961f"
   },
   "outputs": [],
   "source": [
    "# This function will raise an error\n",
    "def empty_function():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8K3hbHn_-sFK"
   },
   "outputs": [],
   "source": [
    "# This function will pass\n",
    "def empty_function():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NBYHYcDM1H2U"
   },
   "source": [
    "### Docstrings\n",
    "\n",
    "At this point we theoretically know how to write really powerful and versatile functions, but there is one important part missing: the **docstring**.\n",
    "\n",
    "The docstring is not required to write a working function, but it's a characteristic of a good programmer to include docstrings into self-written functions. The docstring follows directly after the colon. It is the first part of the indented code block. It is basically the documentation of what the function is doing. The docstring starts and ends with three `\"`. For really obvious functions a one-liner is enough, but if your function is more complex the docstring should include a brief description of the required input arguments, the output of the function and what it is doing. If you want to learn more about docstirngs you can visit the [documentation page](https://www.python.org/dev/peps/pep-0257/). \n",
    "\n",
    "\n",
    "Suggested syntax for a multi-line docstring:\n",
    "```\n",
    "   \"\"\"Example function with PEP 484 type annotations.\n",
    "\n",
    "    Args:\n",
    "        param1: The first parameter.\n",
    "        param2: The second parameter.\n",
    "\n",
    "    Returns:\n",
    "        The return value. True for success, False otherwise.\n",
    "\n",
    "    \"\"\"\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tzPlfPmd1W0P"
   },
   "outputs": [],
   "source": [
    "# Function with one-liner docstring\n",
    "def square(n):\n",
    "    \"\"\"Takes in a number n, returns the square of n\"\"\"\n",
    "    return n**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pcXhC_Sr3G0M"
   },
   "outputs": [],
   "source": [
    "square(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jsYT4Clx3sql"
   },
   "outputs": [],
   "source": [
    "# Function with multi-line docstring\n",
    "def string_reverse(str1):\n",
    "    \"\"\"Returns the reversed String.\n",
    "\n",
    "    Args:\n",
    "        str1 (str):The string which is to be reversed.\n",
    "\n",
    "    Returns:\n",
    "        reverse(str1):The string which gets reversed. \n",
    "\n",
    "    \"\"\"\n",
    "    reverse_str1 = ''\n",
    "    i = len(str1)\n",
    "    while i > 0:\n",
    "        reverse_str1 += str1[i - 1]\n",
    "        i = i- 1\n",
    "    return reverse_str1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6s6L-3633IFU"
   },
   "outputs": [],
   "source": [
    "string_reverse(\"data science is awesome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xI5EzixDVa_H"
   },
   "source": [
    "## Check your understanding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DLN8yvLDQ_MJ"
   },
   "source": [
    "Which of the following function definitions are valid and why? If you need help, type the functions into a new cell and run it. \n",
    "\n",
    "```\n",
    "1. def my_func1(var1='Hello', var2): \n",
    "        pass\n",
    "\n",
    "2. def my_func2(var1, var2='Hello'): \n",
    "        pass\n",
    "\n",
    "3. def my_func3(var1, var2=35): \n",
    "        pass\n",
    "\n",
    "4. def my_func4(var1=35, var2): \n",
    "        pass\n",
    "\n",
    "5. def my_func5(var1=35, var2='Hello'): \n",
    "        pass\n",
    "\n",
    "6. def my_func6(var1, var2): \n",
    "        pass\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rNpW48CQUigk"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show the answer.\n",
    "</summary>\n",
    "\n",
    "1. Not valid. Non-default argument follows default argument.\n",
    "2. Valid.\n",
    "3. Valid.\n",
    "4. Not valid. Non-default argument follows default argument.\n",
    "5. Valid.\n",
    "6. Valid\n",
    "\n",
    "</detail>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aH97kwiIVdap"
   },
   "source": [
    "Which of the following function calls are valid and why?\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "1. my_function_1(3, 5)\n",
    "\n",
    "2. my_function_2(d=\"Data\", \"Science\")\n",
    "\n",
    "3. my_function_3(42, e=\"answer\")\n",
    "\n",
    "4. my_function_4(b=\"neue\", c=\"fische\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3dEHYbq3YabL"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show the answer.\n",
    "</summary>\n",
    "\n",
    "1. Valid.\n",
    "2. Not valid. Positional argument follows keyword argument.\n",
    "3. Valid.\n",
    "4. Valid.\n",
    "\n",
    "</detail>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dz4o52vgUNMM"
   },
   "source": [
    "\n",
    "Now its time for you to write some functions on your own. Try to figure out how to write functions which perform the following tasks.\n",
    "\n",
    "1. Write a function that returns all even numbers from 0 to n.\n",
    "\n",
    "2. Write a function that returns all multiples of a given number called divisor up to another number n. If n would be 18 and the divisor 5 the ouput should be 0, 5, 10, 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T6OqmYnEScJ2"
   },
   "outputs": [],
   "source": [
    "# Function returning evens up to n\n",
    "def get_evens():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5c5yvxXcTRyp"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show a hint.\n",
    "</summary>\n",
    "\n",
    "To write this function you need to combine a lot of the concepts you've learnt so far. You will need list, a for loop and an if-then statement.\n",
    "\n",
    "</detail>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OaLKQIvwS0kR"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show a possible answer.\n",
    "</summary>\n",
    "\n",
    "```\n",
    "def get_evens(n): \n",
    "    evens = []\n",
    "    for element in range(n): \n",
    "        if element % 2 == 0: \n",
    "            evens.append(element)\n",
    "    return evens\n",
    "```\n",
    "\n",
    "</detail>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Rri_uL8GT9kO"
   },
   "outputs": [],
   "source": [
    "# Function returning multiples \n",
    "def get_multiple():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xQOY-LaOaR-R"
   },
   "source": [
    "<details><summary>\n",
    "Click here to show a possible answer.\n",
    "</summary>\n",
    "\n",
    "```\n",
    "def get_multiples(n, divisor): \n",
    "    multiples_list = []\n",
    "    for element in range(n): \n",
    "        if element % divisor == 0: \n",
    "            multiples_list.append(element)\n",
    "    return multiples_list\n",
    "```\n",
    "\n",
    "</detail>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eYpNRG8U4W-d"
   },
   "source": [
    "## Summary\n",
    "\n",
    "Congratulations! You made it to the end of the notebook on functions. \n",
    "\n",
    "After working you way through this notebook you should now...\n",
    "* know what a function is and why you should use them\n",
    "* know about positional and keyword arguments\n",
    "* know how to define default values for parameters \n",
    "* be able to write your own functions \n",
    "* know what a docstring is and how to use it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_P6kBfWQ4Qqw"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "4_Functions.ipynb",
   "provenance": []
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}