Week 04 - Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 04 - Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions means transforming an input (to an output). Which is a powerful concet brought from mathematics. For example, we can double the values of $x$ which makes the function represented as $f(x)\\;=\\;2x$. In this example, an input $x$ will become $2x$ after applying the function. \n",
    "\n",
    "In computer science, this is a broader concept. Meaning not just numbers are able to be transformed. We can transform strings or event objects to help us. Let us see the basic syntax of functions in Python. \n",
    "```Python\n",
    "def foo (input): \n",
    "    pass\n",
    "```\n",
    "In Python, we start notifying the conputer we have a function to use with the keyword `def`. It then follows the name of the function, in which we call it as `foo`. The bracket means what input do we want to use for this function. Finally, the `pass` keyword means we don't have anything inside the function, otherwise the computer will get confused and raise an error. \n",
    "\n",
    "Remember, the contents of the function must be indented. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sum up: \n",
    "* functions start with `def` and then its name\n",
    "* the brackets contains its input(s)\n",
    "* optionally, there can be no inputs\n",
    "* the contents are indented\n",
    "* the `return` keyword are the outputs (optional, if not needed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we defined the function `foo`, we use the function by calling it within the main program. Which is \n",
    "```Python\n",
    "a = foo(1)\n",
    "```\n",
    "This line of code means we let 1 as an input to the function `foo`, and it will return nothing at the end to the variable `a`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution_first": true
   },
   "source": [
    "What is value of `a`? How can you find it out using Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def foo(input): \n",
    "    pass\n",
    "\n",
    "a = foo(1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden"
   },
   "source": [
    "The above demonstration shows that functions don't make outputs if we don't specify them. To do so, we use the `return` keyword. This means the variable(s) will be the output and the computer will exit from the function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_people(ls): \n",
    "    count = 0\n",
    "    for i in range(len(ls)): \n",
    "        count += 1\n",
    "    return count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should see that the function is return the variable called `count`. In fact, returning an object relies on the user. If the user did not return anything, the function will return `None`. This is a special object in Python, means nothing. We can see this analogy below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/toilet_roll.png\" width=\"620\"/>\n",
    "<figcaption><i>Photo from Jonathan Nelson https://twitter.com/iamelgringo/status/845027370864001024</i></figcaption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above analogy outlines what is `None` and compare it to `0` in Python. `0` means the variable has value of zero, but not nothing. While the right hand side represents `None`, it can't be computed with integers or any other objects. \n",
    "\n",
    "So make sure you have returned something. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if your function just needed to print out something, it has not be needed to return anything. For instance, \n",
    "```python\n",
    "def get_status(self): \n",
    "    print(self.status)\n",
    "```\n",
    "Which means if the user needs to see the status of the object, they can simply print what they wanted to see. You will know more about the code above later in the course. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ The following code has an error. What is the error? How can we fix it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b): \n",
    "    a + b\n",
    "a = 12\n",
    "b = 22\n",
    "print('The sum of {} and {} is {}.'.format(a, b, sum(a, b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__\n",
    "\n",
    "Add/ include `return a+b` to the function `add()`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ The following code does not behave what it expected. How can we fix it? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [],
   "source": [
    "def multiply(a, b): \n",
    "    a = 2*a\n",
    "    b = 2*b\n",
    "a = 12\n",
    "b = 22\n",
    "print('{} and {}'.format(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__\n",
    "\n",
    "Add the `return` keyword and ask it to return both `a` and `b`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to keep in mind that, it is important that a function itself is isolated to the main code. For instance, all variables outside does not affect what is inside the function. Let us see an example, \n",
    "```python\n",
    "def some_fn(): \n",
    "    a = 'I am inside the function now'\n",
    "```\n",
    "If one wishes to print the statement. They could do \n",
    "```\n",
    "print(a)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ What will happen? Use the code snippet below to find out how. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test yourself\n",
    "def some_fn(): \n",
    "    a = 'I am inside the function now'\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you have seen, the variable `a` is not defined. The reason is the computer remembers the content of the function first, and assigns the variable in there __separately__ with the main code. So make sure you have defined your variables outside the function, then define them properly into the parameters. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Documentations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Documentations provides a how-to guide for how to use the packages. In particular, they have the biggets portion upon their functions. So let us look at what do they mean. \n",
    "\n",
    "First let us look at the `sum()` in `numpy`. Here's the [documentation](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html). Let's go through the documentation and what do they mean. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Question__ What does the function do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Question__ What are the inputs?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Question__ Does `numpy.sum()` return anything? What would they be?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Question__ The following snipnet uses `np.sum()` and encounters and error. What do think has happened?\n",
    "```python\n",
    "import numpy as np\n",
    "np.sum([['1', '1'],['-1', '0']],[['-1', '2'],['0', '3']])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test your throughts below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In documentations, they will tell you: \n",
    "* _parameters_ these are the inputs for the function.\n",
    "    * `self` means the object itself, will explain in few weeks.\n",
    "    * `*args` means any number of parameters. \n",
    "* _return_ the outputs.\n",
    "\n",
    "Often better documentations will explain what types for parameters and outputs. This would present `TypeError`, which raises when the function input does not fit into what it specifies. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Look at another function's documentation and repeat the same questions again. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calling a Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To call a function, we need to write the function name with the inputs inside the bracket after the function. For example, if we want to call a function called `sum` with the input `user_inputs`, then we would write \n",
    "```python\n",
    "sum(user_input)\n",
    "```\n",
    "This function is used to do add 3 from the user's input. Which means the function should have returned the summed value. However, the above code means we compute the sum and the value will not be assigned to anywhere after this. So the computer will forget all the effort that has been done. \n",
    "\n",
    "So we need to assign the summed value to a variable. Which is \n",
    "```python\n",
    "s = sum(user_input)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Use the built-in `sum()` function to find the sum of a list. The list is given to you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [1, 3, 9, 11, 13, 23, 67]\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "127\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "ls = [1, 3, 9, 11, 13, 23, 67]\n",
    "print(sum(ls))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ A predefined function called `happy_fn` has no inputs, but it will print out the word `happy`. Your client wish to see the text `'I'm so happy now!'`. How could you change the code to let this happen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import modules.happy_function as happy\n",
    "\n",
    "'''\n",
    "Your code here\n",
    "'''\n",
    "??? = happy.???\n",
    "\n",
    "print('I\\'m so {} now!'.format(???))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "import modules.happy_function as happy\n",
    "\n",
    "happy = happy.happy_fn()\n",
    "print('I\\'m so {} now!'.format(happy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can return more than 1 variables. For example \n",
    "```python\n",
    "def new_pair(a, b): \n",
    "    a = a+b\n",
    "    b = a*b\n",
    "    return a, b\n",
    "```\n",
    "Thus the function `new_pair()` will return both `a` and `b`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what does this this output mean? In fact we can check their type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def new_pair(a, b): \n",
    "    a = a+b\n",
    "    b = a*b\n",
    "    return a, b\n",
    "print(type(new_pair(1,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is like a list, but their elements cannot be altered (i.e. immutable). The format of a tuple in Python is \n",
    "```python\n",
    "('hello', ':)', 'world')\n",
    "```\n",
    "This means the output of `new_pair()` is a tuple, but we can unpack the elements into separate variables. This is called unpacking in Python. To unpack a function, we do \n",
    "```python\n",
    "a, b = new_pair(1,3)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ What will the answer of `a` and `b` be? Test them below by adding some code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_pair(a, b): \n",
    "    a = a+b\n",
    "    b = a*b\n",
    "    return a, b\n",
    "a, b = new_pair(1,3)\n",
    "\n",
    "# What is a and b?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a function `eldest_person()` that will return the eldest person and her age. The 2 lists are given to you. Report this person by saying `'The eldest person is {} at {} years old.'`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The eldest person is Sam at 68 years old.\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "names = ['Kia', 'Mohammad', 'Ayesha', 'Sam', 'Roger']\n",
    "age = [23, 25, 17, 68, 32]\n",
    "\n",
    "def eldest_person(names): \n",
    "    eldest = names[0]\n",
    "    oldest_age = age[0]\n",
    "    for i in range(len(names)): \n",
    "        if age[i] > oldest_age: \n",
    "            eldest = names[i]\n",
    "            oldest_age = age[i]\n",
    "    return eldest, oldest_age\n",
    "\n",
    "eldest, oldest_age = eldest_person(names)\n",
    "\n",
    "print('The eldest person is {} at {} years old.'.format(eldest, oldest_age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code\n",
    "names = ['Kia', 'Mohammad', 'Ayesha', 'Sam', 'Roger']\n",
    "age = [23, 25, 17, 68, 32]\n",
    "\n",
    "def eldest_person(): \n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda Functions (Optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions is one way to write functions in Python. For example, if we try to double the input we can write\n",
    "```python\n",
    "double_x = lambda x: 2*x\n",
    "```\n",
    "This is the same as \n",
    "```python\n",
    "def double_x (x): \n",
    "    return 2 * x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To call the lambda function we use the normal convention. For example\n",
    "```python\n",
    "double_x(2)\n",
    "```\n",
    "will return $4$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run me\n",
    "double_x = lambda x: 2* x\n",
    "double_x(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can also be used with multiple arguments like: \n",
    "```python\n",
    "lambda x, y:  2*x + y\n",
    "```\n",
    "Which means we input the two numbers and double the first add them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map, Filter, Reduce (Optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The application of lambda functions is __not__ by assigning them to a variable in fact. There are unique uses of lambda functions in Python, which combines with: \n",
    "* `map()` - Apply the lambda function into a list of elements. \n",
    "* `filter()` - Selects the list elements that is true, decided from the lambda function. \n",
    "* `reduce()` - Use all list elements and apply them with the same lambda function (e.g. sum all of them together). \n",
    "\n",
    "Let us see some examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x21fc6845940>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [0, 1, 2, 3, 4]\n",
    "map(lambda x: 2*x, ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It converts to a map element, so we need to cast it into a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: 2*x, ls))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following sees where `filter()` filters all list elements is greater than $0$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [0, 1, 2, 3, 4]\n",
    "list(filter(lambda x: x > 0, ls))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "__Exercise:__ What happens if we use the opposite comparison operator? Where now we use less than $0$ in the lambda function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__ \n",
    "We see an empty list with \n",
    "```python\n",
    "ls = [0, 1, 2, 3, 4]\n",
    "list(filter(lambda x: x > 0, ls))\n",
    "```\n",
    "We get `[]`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now look at `reduce`, which the first argument is from the previous iteration and the latter is the newer one. So the following means \"Sum from previous iterations\" + `ls[i]`, and it behaves as a sum. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "ls = [0, 1, 2, 3, 4]\n",
    "\n",
    "# Perform sum\n",
    "reduce(lambda x, y: x + y, ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a note, these functions including lambda functions are not restricted to numerical computations. We can use string functions/ methods and apply to string elements. It also can be applied to any types of iterables, such as `numpy` arrays or iterators. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are some exercises to do in the spare time. There are no right or wrong answers, and you are free to explore any assumptions and alternate solutions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `sum` that will add 2 numbers given. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `subtract` that the first input (argument) will subtract the second. If the answer is less than 0, then return 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `average` that will return the average of a list of numbers. You will need to supply the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `average_age` that will return the average age of the guests. You will need to extend the dictionary to test the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "guests = {'Mary': 23, 'May': 22, 'Sam': 21, 'Jarad': 19, 'Joseph': 25, 'Myra': 22}\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `fillnan` that will fill all the missing data as 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_lists = [6, 0, 0, 1, 9, 5, 6, ' ', 8, 6, 'nan', 1, 1, 4, 6, ' ', 9, 6, 4, 6, 9, 'nan', 5, 6, 6]\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a function `anagram` that will revert the order of a word. It does not have to be proper in this case (we could check it separately). However, you must check if the string is a word (i.e. no spaces or characters that does not belong to a word). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_word = 'listen'\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Use a built-in function to find the type of `a` below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 28\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a built-in function called `sorted`, which sorts the lists in order. The documentation is in below\n",
    "\n",
    "[https://docs.python.org/3/howto/sorting.html](https://docs.python.org/3/howto/sorting.html)\n",
    "\n",
    "__Exercise:__ Use the `sorted` function to sort the list below. Find out the median opinion (you don't have to write a function if you don't want to). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opinions = [6, 4, 1, 1, 9, 5, 6, 5, 8, 6, 6, 1, 1, 4, 6, 8, 9, 6, 4, 6, 9, 6, 5, 6, 6]\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function `common` that will pick the common elements of 2 lists. The lists are given to you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls01 = [1, 2, 1, 1, 1, 0, 3, 1, 2, 5]\n",
    "ls02 = [5, 3, 1, 2, 5]\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, there is a way to write functions in one line. This is called the lambda function. For example, a function will double the number, which will be \n",
    "```python\n",
    "lambda x: 2*x\n",
    "```\n",
    "\n",
    "__Exercise:__ Write a lambda function that will do the same thing as the `add()` function above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Try yourself\n",
    "y = lambda x: 2*x\n",
    "print(y(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Extension Reading__\n",
    "\n",
    "* [https://www.datacamp.com/community/tutorials/functions-python-tutorial](https://www.datacamp.com/community/tutorials/functions-python-tutorial)\n",
    "* [https://realpython.com/python-kwargs-and-args/](https://realpython.com/python-kwargs-and-args/)\n",
    "* [https://book.pythontips.com/en/latest/map_filter.html](https://book.pythontips.com/en/latest/map_filter.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In today, we have seen: \n",
    "* Syntax of writing functions\n",
    "* Understand the importance of `return` keyword. \n",
    "* Understand the importance of local and global scopes. \n",
    "* How to read documentations. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}