Lesson 5: Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-xGQqlsBVBHz"
   },
   "source": [
    "# What We Covered So Far\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bctablOdVF56"
   },
   "source": [
    "\n",
    "### Data types\n",
    "[X] Variables    \n",
    "[X] Types (Boolean, Int, Float, Strings)     \n",
    "### Data transformation\n",
    "[X] Arithmetic (+,  -, *, /, ** , %, )    \n",
    "[X] Type conversion       \n",
    "[X] Conditionals  (if/elif/else)\n",
    "[X] Methods    \n",
    "### Handling collections\n",
    "[X] Collection types: list, string,...    \n",
    "[X] Loops    \n",
    "[X] Lists   \n",
    "​\n",
    "### Functions\n",
    "[_] Function Definition   \n",
    "\n",
    "[_] Function Return Values\n",
    "\n",
    "​\n",
    "### Files\n",
    "[_] ...\n",
    "​\n",
    "### Dictionaries\n",
    "[_] ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aIwXUYrEF0k_"
   },
   "source": [
    "# Structure for todays lesson\n",
    "\n",
    "1.   Recap what we learned so far (see above)\n",
    "2.   What is a function in general\n",
    "3.   What is a function in python\n",
    "4.   How to write your own function\n",
    "5.   Menti Quiz\n",
    "6.   Mini Excercise all together\n",
    "7.   Break ( around  8 p.m.)\n",
    "8.   Excercises in Breakout Sessions (starting around 8:15 p.m.)\n",
    "9.   Recap (around 8:45 p.m.) \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "koW_skkAky7F"
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zi7iTt5-nOwY"
   },
   "source": [
    "\n",
    "You already used a few functions:\n",
    "-  `print()`\n",
    "- `input()`\n",
    "- `range()`\n",
    "- `type()`\n",
    "- `list(), str(), int(), float(), bool()`\n",
    "- ...\n",
    "\n",
    "Today we will learn:\n",
    "* **What** is a function\n",
    "* **How** can we write our own functions\n",
    "* **Why** are functions useful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8R-Nv6067omw"
   },
   "source": [
    "## 1. What is a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a useful device that groups together a set of statements so they can be executed multiple times. We specify some parameters to be inputs to the function. A function helps us to avoid writing the same code again and again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 588,
     "status": "ok",
     "timestamp": 1588869757788,
     "user": {
      "displayName": "Suleman Sami",
      "photoUrl": "",
      "userId": "10013056066699523321"
     },
     "user_tz": -120
    },
    "id": "FBAtuv9W-3Ga",
    "outputId": "0f29400a-a562-42dd-b50b-ee43fd4f9d51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5 3.0\n"
     ]
    }
   ],
   "source": [
    "def linearity(x):\n",
    "  output = 0.5 * x + 2 # dont have to write same thing multiple times\n",
    "  return output\n",
    "\n",
    "f1 = linearity(1)\n",
    "f2 = linearity(2)\n",
    "print(f1,f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 554,
     "status": "ok",
     "timestamp": 1588869837610,
     "user": {
      "displayName": "Suleman Sami",
      "photoUrl": "",
      "userId": "10013056066699523321"
     },
     "user_tz": -120
    },
    "id": "wVX_GhgBBOFp",
    "outputId": "7f2f90ab-9cac-48b9-89e9-5ee0d493b11b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "3.0\n",
      "3.5\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "for x in range (1,5):\n",
    "  n = linearity(x)\n",
    "  print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xF9OOAk64SX3"
   },
   "source": [
    "\n",
    "### 1.1 Functions from school\n",
    "Function definition from math classes in (High) School:\n",
    "\n",
    "```\n",
    "y = f(x)\n",
    "f(x) = 0.5x + 2  # f(1) = 0.5 (1) + 2 = 2.5\n",
    "                  # f(1) = 2.5\n",
    "```\n",
    "![image.png](data:image/png;base64,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)\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look of the pattern:\n",
    "\n",
    "\n",
    "* Every function has an input (in this case x)\n",
    "* they transform the input\n",
    "* And might return a value (in this case y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8MHo99Vw5-4Y"
   },
   "source": [
    "### 1.2 Functions in Python\n",
    "\n",
    "Functions in python are very similar:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IjmslIPNo7QR"
   },
   "source": [
    "- they have a ***specific name*** (like variables)\n",
    "> `print`  \n",
    "> `input`\n",
    "\n",
    "- they are executed by appending ***round parantheses***\n",
    "> `print()`   \n",
    "> `input()`\n",
    "\n",
    "- they can have zero, one or more ***parameters***\n",
    "> `print()         # Will print an empty line`   \n",
    "> `print('Hello', 'World')  # Hello World`   \n",
    "> `input('Hello')  # Will crash for more parameters`=\n",
    "\n",
    "- Some ***Magic** happens \n",
    "> `print()  # Prints stuff`   \n",
    "> `input()  # Allows user input into a running Python program`\n",
    "\n",
    "- they ***can*** (no must) ***return*** a value\n",
    "> `print('Hello', 'World', end='!\\n')      # does not return anything`    \n",
    "> `return_value = input()      # return value can be preserved by assingning it to a variable` \n",
    "\n",
    "- perform ***one task*** and they perform it ***well and reliably***\n",
    "\n",
    "\n",
    "- you can ***reuse*** and if you want to change the functionality you only have to change it in one place"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M1k1Mt5L7HLk"
   },
   "source": [
    "#### 1.2.1 Creating a simple function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gM84fCyV70ty"
   },
   "outputs": [],
   "source": [
    "def my_function(x):\n",
    "  result = 0.5 * x + 4\n",
    "  return result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 663,
     "status": "ok",
     "timestamp": 1586452591200,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "aeEyfWnd8TGP",
    "outputId": "d36c8550-ead2-46ba-97ff-8a9f88af5cd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n"
     ]
    }
   ],
   "source": [
    "y = my_function(1)\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 804,
     "status": "ok",
     "timestamp": 1586452729595,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "zzAV14O68xSM",
    "outputId": "db24e842-bf72-414b-afad-c750f398ac79"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104.0\n"
     ]
    }
   ],
   "source": [
    "y = my_function(200)\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 639,
     "status": "ok",
     "timestamp": 1586452741425,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "QGkKpgaR86nh",
    "outputId": "dca6f3f5-6492-4532-8467-6a46d8316884"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "504.0\n"
     ]
    }
   ],
   "source": [
    "y = my_function(1000)\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-k8m_021MIO6"
   },
   "source": [
    "\n",
    "### **Exercise - Functions, List and Loops**\n",
    "\n",
    "(1) Write a function to test whether all numbers of a list are greater than\n",
    "10 return ----> True.\n",
    "\n",
    "test_list_1 = [12, 9, 6, 10, 2, 1, 5, 90]\n",
    "\n",
    "Test whether your function works by feeding in the test_lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "a8fi3r_uEFC2"
   },
   "outputs": [],
   "source": [
    "def test_a_list(input_list):\n",
    "    for item in input_list:\n",
    "        if item <= 10:\n",
    "            return False\n",
    "        else:\n",
    "            continue\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "test_list_1 = [12, 9, 6, 10, 2, 1, 5, 90]\n",
    "print(test_a_list(test_list_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "test_list_2 = [12, 19, 16, 190, 12, 11, 15, 90]\n",
    "print(test_a_list(test_list_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SSzXOvmb9Ogi"
   },
   "source": [
    "#### 1.2.2 More functions\n",
    "\n",
    "* A function that adds two number\n",
    "* A function that substracts two numbers\n",
    "* A function that checks if a number is even or not\n",
    "* A function that returns a list with numbers from their two parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1150,
     "status": "ok",
     "timestamp": 1586452811119,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "9zY0QCVatMN4",
    "outputId": "32bd12b4-790b-4568-9068-2c9270061412"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "# A function that adds two number\n",
    "def add_two_numbers(a,b):\n",
    "  return a + b\n",
    "\n",
    "print(type(add_two_numbers))\n",
    "value = add_two_numbers(6, 12)\n",
    "print(value)  # Expect this to be 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 711,
     "status": "ok",
     "timestamp": 1586452919397,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "SjY3-8pkte_K",
    "outputId": "48377740-bf1f-44db-94dd-16885b86a035"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "# A function that substracts two numbers\n",
    "\n",
    "def substract_two_numbers(a,b):\n",
    "  return a - b\n",
    "\n",
    "number = substract_two_numbers(100, 77)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 561,
     "status": "ok",
     "timestamp": 1586452986828,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "FZ8kPkEOuNBG",
    "outputId": "f928d40f-a313-4b40-ee3f-6fa76689e297"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# A function that checks if a number is even or not\n",
    "\n",
    "def is_even(value):\n",
    "  return value % 2 == 0\n",
    "\n",
    "result = is_even(2)\n",
    "print(result)\n",
    "\n",
    "result = is_even(3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 700,
     "status": "ok",
     "timestamp": 1586453230862,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "jkUPfrkcuVQA",
    "outputId": "533f6b85-8cd5-4ca4-83f1-f6bec0956be2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# A function that returns a list with numbers from their two parameters\n",
    "def get_list_of_numbers(start,end):\n",
    "  current_value = start \n",
    "  results = []\n",
    "  while current_value <= end:\n",
    "    results.append(current_value)\n",
    "    current_value += 1\n",
    "  return results \n",
    "\n",
    "result = get_list_of_numbers(start=3,end=10)\n",
    "result = get_list_of_numbers(3,10)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ayddL-JsHgQH"
   },
   "source": [
    "### 1.3 Menti Quiz\n",
    "\n",
    "\n",
    "Let's go menti.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h65WRh6XtSuR"
   },
   "source": [
    "### 1.3 Functions Syntax Recap\n",
    "#### 1.) Start with `def`\n",
    "Every function starts with `def` keyword ( shorthand for *define*)\n",
    "\n",
    "#### 2.) Give your function a name   ---   `add_two_numbers`\n",
    "Use the name to execute the function anywhere after it was created. Make it as descriptive as possible!\n",
    "\n",
    "#### 3.) Inside round brackets, define a set of parameters --- `(a, b)`\n",
    "We will look into this a bit more closely later\n",
    "\n",
    "#### 4) Then end your line with a colon --- `:`\n",
    "Note how this is consistent with how you have used colons followed by indented code before\n",
    "\n",
    "#### 5) Indented code block -> the logic of the function\n",
    "Here you can do everything that you learned so far and are about to learn!\n",
    "\n",
    "#### 6) If you want to return a value, add a line that starts with `return`\n",
    "As soon as a function returns something, it stops! Otherwise it will run untill the end of the indented block\n",
    "\n",
    "#### 7) Use your function like any other function\n",
    "You are done! :-)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "D3yo3bXz1AII"
   },
   "source": [
    "### Exercise 1 - Create your very own first function!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 103
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 525,
     "status": "ok",
     "timestamp": 1586454985661,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "M5DTAR1Kx-Qn",
    "outputId": "be39ba0a-abd3-4261-df4b-4ad4645df232"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're in the function now\n",
      "2\n",
      "4\n",
      "We're out of the function\n",
      "8\n",
      "\n",
      "We're in the function now\n",
      "2\n",
      "4\n",
      "We're out of the function\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# 1.) It should be called multiply_two_numbers \n",
    "# 2.) It should take two numbers as parameters\n",
    "# 3.) It should return the product of its two numbers\n",
    "\n",
    "def multiply_two_numbers(a, b):\n",
    "  print(\"We're in the function now\")\n",
    "  print(a)\n",
    "  print(b)\n",
    "  z = a * b\n",
    "  return z \n",
    "\n",
    "a = 2\n",
    "b = 4\n",
    "z = multiply_two_numbers(a,b)\n",
    "print(\"We're out of the function\")\n",
    "print(z)\n",
    "print('')\n",
    "result = multiply_two_numbers(a,b)\n",
    "print(\"We're out of the function\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y4JMBWOs1cEH"
   },
   "source": [
    "###  1.4 Returning values \n",
    "Some more words on Returning Values\n",
    "\n",
    "Consider the follwing lines of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 633,
     "status": "ok",
     "timestamp": 1586456156320,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "t9OAwzZvJkxm",
    "outputId": "a43a7aa2-7f4a-490f-e3b6-9c35a5871d11"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\n",
      "diff inside function: -10\n",
      "None\n",
      "number_diff outside function: None\n"
     ]
    }
   ],
   "source": [
    "def diff_two_numbers(number1, number2):\n",
    "    diff = number1 - number2\n",
    "    print(f\"diff inside function: {diff}\")\n",
    "  \n",
    "print(\"Start\")\n",
    "number_diff = diff_two_numbers(10, 20)\n",
    "print(number_diff)\n",
    "\n",
    "print(\"number_diff outside function:\", number_diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_y-0AmPCLZms"
   },
   "source": [
    "##### Takeaway"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "z8Z5Dw6fITc4"
   },
   "source": [
    "The above code will produce a mistake!     \n",
    "`number_diff` is only produced ***inside*** the function not outside the function.    \n",
    "\n",
    "- **The only way to get a value out of a function is by using `return`. Every value that is not returned will stay inside the function.** \n",
    "\n",
    "\n",
    "-------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1799,
     "status": "ok",
     "timestamp": 1586456223869,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "jnRjikwOKGR6",
    "outputId": "a6041a57-93af-4622-83a6-ce50457fe8d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number_sum inside function: 3000\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# You can return Nothing\n",
    "def add_two_numbers_3(number1, number2):\n",
    "    number_sum = number1 + number2\n",
    "    print(\"number_sum inside function:\", number_sum)\n",
    "    return\n",
    "  \n",
    "number = add_two_numbers_3(1000, 2000)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 626,
     "status": "ok",
     "timestamp": 1586456272003,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "rnvGXlxiL4Zu",
    "outputId": "68efd5e9-f26c-408b-b506-6c87d247fafc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(300, 20000, 100)\n"
     ]
    }
   ],
   "source": [
    "# You can also return multiple values with a Tuple\n",
    "def add_and_multiply_two_numbers(number1, number2):\n",
    "    number_sum = number1 + number2\n",
    "    number_product = number1 * number2\n",
    "    return number_sum, number_product, 100\n",
    "\n",
    "numbers = add_and_multiply_two_numbers(100, 200)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "itrf7BAqNbyo"
   },
   "source": [
    "## 2. More examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l5_kybpAEGjz"
   },
   "source": [
    "### Example 1 - Is Devisable by Check\n",
    "\n",
    "\n",
    "We want a function that checks for any given real number (`number_1`) if it devisible without any rest by another given real number  (`nubmer_2`):\n",
    "\n",
    "You can use the modulo operation to see if there is some reminder in a division operation:\n",
    "```\n",
    "number_1 % number_2 == 0 \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1170,
     "status": "ok",
     "timestamp": 1586458640159,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "IY8OE0ppO2so",
    "outputId": "fd6ff9e8-1f9e-4dd5-9008-bee6ce8bd769",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def is_devisable(number_1, number_2):\n",
    "    print(\"test\")\n",
    "\n",
    "\n",
    "  # this is inside the function\n",
    "    return number_1 % number_2 == True\n",
    "\n",
    "# outside the function where you call it\n",
    "result = is_devisable(13,5)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jcY6uQVdvrBD"
   },
   "source": [
    "### Example 2 - Circle Data\n",
    "\n",
    "a) We want to calculate the circumference and area of a circle given its radius\n",
    "\n",
    "Write a function `calculate_circle_data()` that takes one argument that is the value of a circle's radius and returns its area and circumference\n",
    "\n",
    "You can use `pi = 3.1415` for pi\n",
    "\n",
    "As a reminder: \n",
    "\n",
    "```\n",
    "circumference = 2 x pi x radius\n",
    "area = pi x radius x radius\n",
    "```\n",
    "\n",
    "\n",
    "b) Write a function `present_circle_data` that takes 3 arguments: `radius, circumference, area` and prints a nice statement to the console\n",
    "\n",
    "*Example*\n",
    "```\n",
    "present_circle_data(10, 62.3, 314.15)\n",
    "\n",
    "# A Circle with radius 10 has a circumference of 62.3 and an area of 314.15\n",
    "```\n",
    "\n",
    "\n",
    "c) Write a function that will take a list of radiuses, calculate the area and circumference for each and prints the results, using your functions from a) and  b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 971,
     "status": "ok",
     "timestamp": 1588871519878,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "4VRSjS24G2o5",
    "outputId": "930448b2-9bc0-417b-db35-9f7de68a2400"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(62.83185307179586, 314.1592653589793)"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "def calculate_circle_data(radius):\n",
    "    circumference = 2 * pi * radius\n",
    "    area = pi * radius * radius\n",
    "    return circumference, area \n",
    "calculate_circle_data(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yf3KEWkFHTY-"
   },
   "outputs": [],
   "source": [
    "def present_circle_data(radius, circumference, area):\n",
    "    print(f\"A Circle with radius {radius} has a circumference of {circumference} and an area of {area}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "g2TQI-n0Hmcp"
   },
   "outputs": [],
   "source": [
    "def calculate_circle_data_list(radius_list):\n",
    "    for radius in radius_list:\n",
    "        circumference, area = calculate_circle_data(radius)\n",
    "        present_circle_data(radius, circumference, area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 336
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1247,
     "status": "ok",
     "timestamp": 1588871646049,
     "user": {
      "displayName": "Alexander Müller",
      "photoUrl": "",
      "userId": "03815021071088519742"
     },
     "user_tz": -120
    },
    "id": "aBTL1JvZH_mc",
    "outputId": "8216befd-e34f-43ce-bb97-959686d04e0c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Circle with radius 1 has a circumference of 6.283185307179586 and an area of 3.141592653589793\n",
      "A Circle with radius 2 has a circumference of 12.566370614359172 and an area of 12.566370614359172\n",
      "A Circle with radius 3 has a circumference of 18.84955592153876 and an area of 28.274333882308138\n",
      "A Circle with radius 4 has a circumference of 25.132741228718345 and an area of 50.26548245743669\n",
      "A Circle with radius 5 has a circumference of 31.41592653589793 and an area of 78.53981633974483\n",
      "A Circle with radius 6 has a circumference of 37.69911184307752 and an area of 113.09733552923255\n",
      "A Circle with radius 7 has a circumference of 43.982297150257104 and an area of 153.93804002589985\n",
      "A Circle with radius 8 has a circumference of 50.26548245743669 and an area of 201.06192982974676\n",
      "A Circle with radius 9 has a circumference of 56.548667764616276 and an area of 254.46900494077323\n",
      "A Circle with radius 10 has a circumference of 62.83185307179586 and an area of 314.1592653589793\n",
      "A Circle with radius 11 has a circumference of 69.11503837897544 and an area of 380.1327110843649\n",
      "A Circle with radius 12 has a circumference of 75.39822368615503 and an area of 452.3893421169302\n",
      "A Circle with radius 13 has a circumference of 81.68140899333463 and an area of 530.929158456675\n",
      "A Circle with radius 14 has a circumference of 87.96459430051421 and an area of 615.7521601035994\n",
      "A Circle with radius 15 has a circumference of 94.24777960769379 and an area of 706.8583470577034\n",
      "A Circle with radius 16 has a circumference of 100.53096491487338 and an area of 804.247719318987\n",
      "A Circle with radius 17 has a circumference of 106.81415022205297 and an area of 907.9202768874503\n",
      "A Circle with radius 18 has a circumference of 113.09733552923255 and an area of 1017.8760197630929\n",
      "A Circle with radius 19 has a circumference of 119.38052083641213 and an area of 1134.1149479459152\n"
     ]
    }
   ],
   "source": [
    "radius_list = list(range(1,20))\n",
    "\n",
    "calculate_circle_data_list(radius_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IXejDRzxPKdd"
   },
   "source": [
    "### Example 3\n",
    "\n",
    "Write a function that returns a minimum value in a list. \n",
    "\n",
    "Input = [10,23,5,9,1,4]\n",
    "\n",
    "Output = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 652,
     "status": "ok",
     "timestamp": 1588873894966,
     "user": {
      "displayName": "Suleman Sami",
      "photoUrl": "",
      "userId": "10013056066699523321"
     },
     "user_tz": -120
    },
    "id": "POyyR62vP3ub",
    "outputId": "0e9604fd-720f-4e11-bf30-8925587d8218"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def minimum_value(list_of_num):\n",
    "    mini = list_of_num[0]\n",
    "    for x in list_of_num:\n",
    "        if x < mini:\n",
    "            mini = x\n",
    "    return mini\n",
    "\n",
    "list_num = [20,445,70,45,86,898,100]\n",
    "minimum_value(list_num) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mrdh388uOlmY"
   },
   "source": [
    "### Example 4 - Twitter\n",
    "\n",
    "Twitter users can write tweets up to 280 characters long.\n",
    "While a user is writing a tweet, twitter says how many characters are left.\n",
    "When they exceed the 280, it starts counting in negative.\n",
    "\n",
    "-> Write a function remaining_chars(tweet) that prints this number\n",
    "\n",
    "Example:\n",
    "\n",
    "remaining_chars(\"Good morning twitter\")\n",
    "**Output**: `260`\n",
    "\n",
    "remaining_chars(\"\")\n",
    "**Output**: `280`\n",
    "\n",
    "remaining_chars(\"\"\"He has achieved success who has lived well, laughed often, and loved much;\n",
    "Who has enjoyed the trust of pure women, the respect of intelligent men and the love of little children;\n",
    "Who has filled his niche and accomplished his task;\n",
    "Who has never lacked appreciation of Earth's beauty or failed to express it;\"\"\")\n",
    "**Output**: `-28`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 535,
     "status": "ok",
     "timestamp": 1588872718775,
     "user": {
      "displayName": "Suleman Sami",
      "photoUrl": "",
      "userId": "10013056066699523321"
     },
     "user_tz": -120
    },
    "id": "Dx8WRZLbO3jU",
    "outputId": "d64eb721-ab31-46e9-fdba-e9f5da0b7f3f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  -28\n"
     ]
    }
   ],
   "source": [
    "def remaining_chars(twitter_message):\n",
    "    maximum_chars = 280\n",
    "    length = len(twitter_message)\n",
    "    remaining_char = maximum_chars - length\n",
    "    return remaining_char\n",
    "\n",
    "output = remaining_chars(\"He has achieved success who has lived well, laughed often, and loved much; Who has enjoyed the trust of pure women, the respect of intelligent men and the love of little children; Who has filled his niche and accomplished his task; Who has never lacked appreciation of Earth's beauty or failed to express it;\")\n",
    "print(\"Output: \",output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZDWROuRy3BB2"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "You learned today:\n",
    "\n",
    "*   How to organize your code in functions\n",
    "*   How to write your own functions in python\n",
    "* How to handover parameters to functions\n",
    "* How to return values from functions\n",
    "\n",
    "\n",
    "# Feedback\n",
    "Now it is time for feedback:\n",
    "\n",
    "https://redischool.typeform.com/to/unfnHP\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Lesson 6 - Functions.ipynb",
   "provenance": [
    {
     "file_id": "1DscUrg_l-9eDK4cJtMJyqIaaRtaDZqD5",
     "timestamp": 1586434315240
    }
   ],
   "toc_visible": true
  },
  "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": 1
}