01.09 Function definitions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Function definitions<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#The-function-definition\" data-toc-modified-id=\"The-function-definition-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>The function definition</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercise-1\" data-toc-modified-id=\"Exercise-1-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Exercise 1</a></span></li><li><span><a href=\"#Exercise-2\" data-toc-modified-id=\"Exercise-2-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Exercise 2</a></span></li><li><span><a href=\"#Exercise-3\" data-toc-modified-id=\"Exercise-3-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Exercise 3</a></span></li><li><span><a href=\"#Exercise-4\" data-toc-modified-id=\"Exercise-4-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Exercise 4</a></span></li></ul></li><li><span><a href=\"#The-*args-variable-in-function-definitions\" data-toc-modified-id=\"The-*args-variable-in-function-definitions-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>The <em>*args</em> variable in function definitions</a></span></li><li><span><a href=\"#The-*kwargs-variable-in-function-definitions\" data-toc-modified-id=\"The-*kwargs-variable-in-function-definitions-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>The <em>*kwargs</em> variable in function definitions</a></span></li><li><span><a href=\"#Predefined-optional-function-arguments\" data-toc-modified-id=\"Predefined-optional-function-arguments-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Predefined optional function arguments</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## The function definition\n",
    "\n",
    "The concept of **functions** is probably one of the most important in mathematics. In programming languages, too, functions are often used to convert mathematical functions into algorithms. Such a function calculates one or more values and is completely dependent on the input values transferred, the so-called arguments. Beyond the mathematical scope, functions can also be use to fulfill a certain _functionality_ or operation. E.g., it can be very useful to define some parts of your code as a function, if you have to use these parts repeatedly and/or are of complex structure. The general structure of a function definition in _Python_ is as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def function_name(argument_list):\n",
    "    commands(using elments of the argument_list)\n",
    "    return some_variable \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e.g.:\n",
    "def my_sumfunction(x,y):\n",
    "    my_sum=x+y\n",
    "    return my_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_sumfunction(6,23))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_result = my_sumfunction(6,23)\n",
    "print(the_result)\n",
    "print(the_result + 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# erroneous example:\n",
    "x=10\n",
    "y=23\n",
    "print(my_sumfunction(x,y))\n",
    "\n",
    "def my_sumfunction(g,y):\n",
    "    my_sum=x+y\n",
    "    return my_sum\n",
    "\n",
    "g=100\n",
    "print(my_sumfunction(g,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "a=17\n",
    "b=23\n",
    "print(my_sumfunction(x=a,y=b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_sumfunction(x=77,y=23))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# order of the arguments matters:\n",
    "x=100\n",
    "print(f\"x: {x} (before function execution)\")\n",
    "\n",
    "def my_divfunction(x,y):\n",
    "    my_div=x/y\n",
    "    print(f\"x: {x}\")\n",
    "    print(f\"y: {y}\")\n",
    "    return my_div\n",
    "\n",
    "print(my_divfunction(y=23,x=77))\n",
    "print(my_divfunction(23,77))\n",
    "\n",
    "print(f\"x: {x} (after function execution)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `function_name` can be any name you want to give your function. Avoid to use names, which are identical to Python's built-in function names (`list`, `len`, `sum`, `print`, ...)\n",
    "* `argument_list` is a list of one or more variables, that are passed to the function. E.g., in maths, this concept would correspond to $y=y(x)$, $y$  a function of $x$, while $x$ is the ``argument_list``. The ``argument_list`` can of course contain more than one parameter, similar to, e.g., $y=y(x, t, r, ...)$.\n",
    "* `commands` are commands, that are executed within and only within the function (encapsulated) and can use the input parameter from the `argument_list`.\n",
    "* whatever has been calculated or processed inside the function can be _returned_ with variables provided after the `return` command at the end of the function. If you have nothing to return back to your main script, you can skip this point.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The function has to be defined prior to its first call within your script!\n",
    "</div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Avoid to use identical names for variables in your argument-list and for variables in your script. This is not prohibited and Python can handle that, but your code can mess-up very quickly and you quickly lose track of your defined and (somewhere else) processed variables.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also pre-assign values to your arguments:\n",
    "def my_function(x,y=0,z=0):\n",
    "    \"\"\"This is a summation function. \n",
    "        x: first input number \n",
    "        y: first input number \n",
    "        z: first input number \n",
    "    \"\"\"\n",
    "    sum=x+y+z\n",
    "    return sum\n",
    "\n",
    "the_result = my_function(6,23)\n",
    "print(the_result)\n",
    "\n",
    "the_result = my_function(x=6,y=23)\n",
    "print(the_result)\n",
    "\n",
    "the_result = my_function(x=6,y=23, z=11)\n",
    "print(the_result)\n",
    "\n",
    "the_result = my_function(z=11, x=6, y=23)\n",
    "print(the_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Let's apply this concept to the last example from the _if_-conditions chapter:\n",
    "\n",
    "```python\n",
    "new_number_list = list(range(0,22,1))\n",
    "threshold = 10\n",
    "for number in new_number_list:\n",
    "    if number>threshold:\n",
    "        print(f\"match! {number} is greater than {threshold}.\")\n",
    "    else:\n",
    "        print(f\"{number} is below the threshold {threshold}!\")\n",
    "```\n",
    "\n",
    "We want to encapsulate the _operation_ of checking the threshold-condition within a new function `threshold_checker`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": true,
    "hide_input": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# the new function definition:\n",
    "def threshold_checker(value, threshold):\n",
    "    if value>threshold:\n",
    "        print(f\"match! {value} is greater than {threshold}.\")\n",
    "    else:\n",
    "        print(f\"{value} is below the threshold {threshold}!\")\n",
    "\n",
    "new_number_list = list(range(0,22,1))\n",
    "threshold_to_check = 10\n",
    "\n",
    "for number in new_number_list:\n",
    "    threshold_checker(value=number, \n",
    "                      threshold=threshold_to_check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# re-run with a different threshold:\n",
    "threshold_to_check = 15\n",
    "for number in new_number_list:\n",
    "    threshold_checker(number, threshold_to_check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# re-run with a different number list:\n",
    "new_number_list_2 = list(range(10,35,1))\n",
    "threshold_to_check = 15\n",
    "for number in new_number_list_2:\n",
    "    threshold_checker(number, threshold_to_check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "1. Re-write the `threshold_check` function, so that it also contains and executes the _for_-loop. The argument value is then a list of numbers (the `new_number_list`) and no longer a single value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your solution 1.1 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.1:\n",
    "print(\">>>\")\n",
    "# the new function definition:\n",
    "def threshold_checker_for_lists(inputlist, threshold):\n",
    "    for value in inputlist:\n",
    "        if value>threshold:\n",
    "            print(f\"match! {value} is greater than {threshold}.\")\n",
    "        else:\n",
    "            print(f\"{value} is below the threshold {threshold}!\")\n",
    "\n",
    "new_number_list  = list(range(0,22,1))\n",
    "new_number_list_2= list(range(10,35,1))\n",
    "new_number_list_3= list(range(35,40,1))\n",
    "threshold_to_check = 10\n",
    "\n",
    "threshold_checker_for_lists(new_number_list, threshold_to_check)\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# you can also again plug in numbers directly:\n",
    "threshold_checker_for_lists(new_number_list, 18)\n",
    "# but has disadvantages (e.g. when you want to change the\n",
    "# threshold )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# what \"disadvantage\" means:\n",
    "#threshold_checker_for_lists(new_number_list, 30)\n",
    "#threshold_checker_for_lists(new_number_list_2, 30)\n",
    "#threshold_checker_for_lists(new_number_list_3, 31)\n",
    "\n",
    "#better:\n",
    "threshold_to_check=30\n",
    "threshold_checker_for_lists(new_number_list, threshold_to_check)\n",
    "print(\"\")\n",
    "threshold_checker_for_lists(new_number_list_2, threshold_to_check)\n",
    "print(\"\")\n",
    "threshold_checker_for_lists(new_number_list_3, threshold_to_check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# another way to call your function:\n",
    "#inputlist, threshold\n",
    "threshold_checker_for_lists(inputlist=new_number_list, \n",
    "                            threshold=threshold_to_check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Expand your new function, so that it\n",
    "\n",
    "2. remembers the first occurance of a positive threshold-check, and\n",
    "3. returns that value to your main script, that prints it out there.\n",
    "4. To validate your function, change the range of your input list to `new_number_list = list(range(3,22,1))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.2-1.4:\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.2-1.4:\n",
    "# the modified function definition:\n",
    "def threshold_checker_for_lists(inputlist, threshold):\n",
    "    first_occurrence = -1 # -1 acts as a place holder/initial \n",
    "                         #    value \n",
    "    for index in range(len(inputlist)):\n",
    "        if inputlist[index]>threshold:\n",
    "            print(f\"{index}: match! {inputlist[index]} is \"\n",
    "                  f\"greater than {threshold}.\")\n",
    "            if first_occurrence==-1:\n",
    "                first_occurrence=index\n",
    "        else:\n",
    "            print(f\"{index}: {inputlist[index]} is below the \"\n",
    "                  f\"threshold {threshold}!\")\n",
    "    return first_occurrence\n",
    "\n",
    "new_number_list = list(range(9,22,1))\n",
    "threshold_to_check = 10\n",
    "\n",
    "result = threshold_checker_for_lists(new_number_list, \\\n",
    "                                     threshold_to_check)\n",
    "\n",
    "print(f\"first threshold-check at index {result}\")\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slightly alternative solution:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.2-1.4:\n",
    "def threshold_checker_for_lists(inputlist, threshold):\n",
    "    idx_match = 0\n",
    "    first_occurrence = False\n",
    "    for curr_i in range(len(inputlist)):\n",
    "        if inputlist[curr_i]>threshold:\n",
    "            print(f\"at index {curr_i}: {inputlist[curr_i]} > {threshold}.\")\n",
    "            if first_occurrence==False:\n",
    "                first_occurrence=True\n",
    "                idx_match=curr_i\n",
    "        else:\n",
    "            print(f\"at index {curr_i}: {inputlist[curr_i]} < {threshold}.\")\n",
    "    return idx_match\n",
    "\n",
    "new_number_list  = list(range(5,22,1))\n",
    "threshold_to_check = 10\n",
    "where_limit = threshold_checker_for_lists(new_number_list, threshold_to_check)\n",
    "\n",
    "print(f\"first threshold-check at index {where_limit}\")\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "Write a function, that converts temperatures $T$ from Fahrenheit ([F]) to Celsius ([°C]). The formular for the conversion is:\n",
    "\n",
    "$$ T[^\\circ\\text{C}] = \\frac{5}{9} * (T[\\text{F}]-32) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Your solution 2 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 2:\n",
    "print(\">>>\")\n",
    "def fahrenheit_to_celsius(temp_in_fahrenheit):\n",
    "    \"\"\"\n",
    "        This function converts an input temperature in \n",
    "        Fahrenheit to Celsius.\n",
    "\n",
    "        input:\n",
    "            temp_in_fahrenheit - input temperature [F]\n",
    "        ouput:\n",
    "            temp_in_celsius    - temperature [°C]\n",
    "\n",
    "    \"\"\"\n",
    "    temp_in_celsius = 5/9 * (temp_in_fahrenheit- 32)\n",
    "    return temp_in_celsius\n",
    "\n",
    "\n",
    "def celsius_to_fahrenheit(temp_in_celsius):\n",
    "    \"\"\"\n",
    "        This function converts an input temperature in Celsius\n",
    "        to Fahrenheit\n",
    "\n",
    "        input:\n",
    "            temp_in_celsius     - input temperature [°C]\n",
    "        ouput:\n",
    "            temp_in_fahrenheit  - temperature [F]\n",
    "\n",
    "    \"\"\"\n",
    "    temp_in_fahrenheit = 9/5 * (temp_in_celsius) + 32\n",
    "    return temp_in_fahrenheit\n",
    "\n",
    "print(fahrenheit_to_celsius(78.8))\n",
    "print(celsius_to_fahrenheit(26))\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "Note the discrepancy of the two results. One reason is the internal precision of the defined/used variable types, due to which rounding errors can occur. Later we will learn, how to change the precision of a variable type with NumPy.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Write a function `product`, that multiplies all numbers of a given number-list. Apply your function to the list `list1=[4, 8, 12, 16, 20, 32, 28, 24, -1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 3 here:\n",
    "\"\"\" we need sth, that does:\n",
    "     iteration 0: 4*8    = 32\n",
    "     iteration 1: 32*12  = 384\n",
    "     iteration 2: 384*16 = 6144\n",
    "     iteration ...\n",
    "     ...\n",
    "     final result: 2642411520\n",
    "\"\"\"\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 3:\n",
    "def product(inputlist):\n",
    "    \"\"\"Calculates the product of a given number-list\"\"\"\n",
    "    result = 1 # again, we need an initialization of the later result variable\n",
    "    for index in range(0,len(inputlist)):\n",
    "        result = result * inputlist[index]\n",
    "    return result\n",
    "\n",
    "# alternative approach:\n",
    "def product(inputlist):\n",
    "    result = inputlist[0]\n",
    "    for curr_val in inputlist[1:]:\n",
    "        result = result * curr_val\n",
    "    return result\n",
    "\n",
    "list1=[4, 8, 12, 16, 20, 32, 28, -24, -1]\n",
    "print(product(list1))\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "Write a function, that finds the maximum value of a given list. Apply your function to the list defined in Exercise 2.\n",
    "Extra: Also print out the index of the maximum value.\n",
    "\n",
    "Hints: \n",
    "1. Your function should return the maximum and index of the maximum.\n",
    "2. A function can return more than one value:\n",
    "```py \n",
    "    function xyz(X,Y,Z):\n",
    "        result_1 = X*Z\n",
    "        result_2 = X*Y          \n",
    "        return result_1, result_2\n",
    "\n",
    "    val_1, val_2 = xyz(X=0,Y=9,Z=7)\n",
    "    print(val_1, val_2)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Your solution 4 here:\n",
    "list1=[4, 8, 12, 32, 20, 32, 28, 24, -1]\n",
    "\n",
    "\"\"\" your function should return the\n",
    "    maximum and index of the maximum\n",
    "    \n",
    "    A function can return more than one value:\n",
    "    \n",
    "       function xyz(X,Y,Z):\n",
    "          ...\n",
    "          result_1 = X*Z\n",
    "          result_2 = X*Y\n",
    "          \n",
    "          return result_1, result_2\n",
    "\n",
    "        val_1, val_2 = xyz(X=0,Y=9,Z=7)\n",
    "        print(val_1, val_2)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 4:\n",
    "print(\">>>\")\n",
    "def max(inputlist):\n",
    "    index_of_max = 0\n",
    "    maximum = inputlist[index_of_max]\n",
    "    # maximum = inputlist[0]\n",
    "    #index_of_max = 0\n",
    "    for index in range(1,len(inputlist)):\n",
    "        if inputlist[index] > maximum:\n",
    "            maximum = inputlist[index]\n",
    "            index_of_max = index\n",
    "    return maximum, index_of_max\n",
    "\n",
    "list1=[4, 8, 12, 16, 40, 32, 28, -24, -1]\n",
    "current_max, current_max_index = max(list1) # one possible \n",
    "                                            #  output format\n",
    "#(current_max, current_max_index) =  max(list1) # also okay\n",
    "print(f\"maximum: {current_max}, at index: {current_max_index} \")\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## The _*args_ variable in function definitions\n",
    "There are very often cases in which the number of arguments required for the call of a function is not known a priori. E.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 1:\n",
    "def test_static_args(arg1, arg2, arg3):\n",
    "    print(\"arg1:\", arg1)\n",
    "    print(\"arg2:\", arg2)\n",
    "    print(\"arg3:\", arg3)\n",
    "print(test_static_args(1, 'word', 'word 2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Works as defined. But what if you need to add another argument\n",
    "or less then two?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# e.g.:\n",
    "print(test_static_args(1, 'word'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "To overcome this problem we can use a so-called tuple reference, which is preceded by * and put at the end of the argument list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 2:\n",
    "def test_var_args(f_arg, *args):\n",
    "    print(\"first normal arg:\", f_arg)\n",
    "    for counter, arg in enumerate(args, 1):\n",
    "        print(f\"{counter}. optional arg: {arg}\")\n",
    "    return 'end.'\n",
    "\n",
    "print(test_var_args(1, 'i am optional 1', 'optional 2'))\n",
    "print(\" \")\n",
    "print(test_var_args(1, 'only 1 optional'))\n",
    "print(\" \")\n",
    "print(test_var_args(1))\n",
    "print(\" \")\n",
    "print(test_var_args('fixed', '1', '2', '3', '4'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can even skip the standard argument (which is otherwise **always** required) and work just with `*args`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 3:\n",
    "def test_var_args2(*args):\n",
    "    for counter, arg in enumerate(args, 1):\n",
    "        print(f\"{counter}. optional arg: {arg}\")\n",
    "    return 'end.'\n",
    "\n",
    "print(test_var_args2(1, 'word', 5))\n",
    "print(\" \")\n",
    "print(test_var_args2(1, 'word'))\n",
    "print(\" \")\n",
    "print(test_var_args2())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "With `*args`, we are no longer passing a list to the function, but several different positional arguments. The function takes all the arguments that are provided in the input and packs them all into a single iterable object named `args`. `args` is just a name, you can choose any other name that you prefer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The _*kwargs_ variable in function definitions\n",
    "`**kwargs` works just like `*args`, but instead of accepting positional arguments it accepts keyword (_named_) arguments (like _dictionaries_).  E.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 1:\n",
    "def my_concatenate1(**kwargs):\n",
    "    result = \"\"\n",
    "    # Iterating over the keys' values of the kwargs dictionary:\n",
    "    for value in kwargs.values():\n",
    "        result += value\n",
    "    return result\n",
    "\n",
    "print(my_concatenate1(word1=\"Somewhere \", word2=\"over \", word3=\"the \", word4=\"rainbow.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "and"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 2:\n",
    "def my_concatenate2(**kwargs):\n",
    "    result = \"\"\n",
    "    # Iterating over the keys of the kwargs dictionary:\n",
    "    for key in kwargs:\n",
    "        result += key\n",
    "    return result\n",
    "\n",
    "print(my_concatenate2(word1=\"Somewhere \", word2=\"over \", word3=\"the \", word4=\"rainbow.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "or combine keyword with its corresponding value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#Example 3:\n",
    "def my_kwargs_printer(**kwargs):\n",
    "    result = \"\"\n",
    "    # Iterating over the keys and values of the kwargs dictionary:\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"the key {key} has the value {value}.\")\n",
    "    return 'done.'\n",
    "\n",
    "print(my_kwargs_printer(word1=\"Somewhere \", word2=\"over \", word3=\"the \", word4=\"rainbow.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Also here, `kwargs` is just a name that can be changed to whatever you want to.\n",
    "\n",
    "And of course you can combine standard arguments with `*args` and `*kwargs`, just keep the following order:\n",
    "\n",
    "1.\tstandard arguments\n",
    "2.\t*args arguments\n",
    "3.\t**kwargs arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Predefined optional function arguments\n",
    "Another very useful and handy way, to define optional arguments of a function are predefined, but still optional arguments. By assigning an initial value to an argument in the argument list converts that specific argument automatically to an optional, but predefined argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Example:\n",
    "def my_func(x, y=5):\n",
    "    print(f\"x:{x}, y:{y}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Here, `x` is a standard argument that **must** be provided in any call of the function. `y=5` is the **optional, predefined** argument with the intial value 5. You can call the function in different, equivalent ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_func(7, 8) # means, x=7, y=8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can even write the argument's name within the function call, so that the assignment of each value to a specific argument becomes even more clear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "my_func(7, y=8)\n",
    "my_func(x=7, y=8)\n",
    "my_func(y=8, x=7) # by \"naming\" each argument, \n",
    "                  # you can even re-order the input arguments\n",
    "my_func(x=19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Leaving the optional paramter `y` unassigned will cause the function to use its predefined value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "my_func(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "But leaving the standard argument (`x`) will cause an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "my_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "With predefined, but still optional arguments you are more flexible in the way you use your optionally assigned arguments (e.g. when you prototype your function or if you want to keep your main routine flexible and modular)."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.16 | packaged by conda-forge | (default, Feb  1 2023, 16:05:36) \n[Clang 14.0.6 ]"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Function definitions",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "4dbe93ddc4bed5499d29720f38f7446a34b15f2f3201b881b9bf1c1a4baa393f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}