21 - Python 10min a day - Nameless functions a.k.a. lambda functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"assets/jeremy-lapak-CVvFVQ_-oUg-unsplash.png\" alt=\"Python Envs\" style=\"display: block; margin: 0 auto\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python 10 minutes a day #21\n",
    "## Nameless functions a.k.a. lambda functions\n",
    "[Medium article link](https://towardsdatascience.com/learning-python-10-minutes-a-day-21-f1d8eec408d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a [series](https://python-10-minutes-a-day.rocks) of short 10 minute Python articles helping you to get started with Python. I try to post an article each day (no promises), starting from the very basics, going up to more complex idioms. Feel free to contact me on [LinkedIn](https://www.linkedin.com/in/dennisbakhuis/) for questions or requests on particular subjects of Python, you want to know about."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For new-comers, the lambda function can be somewhat intimidating. I have also avoided the use of these functions for some time as I never understood the use of them. Nowadays, I do see a benefit of the construct but it is rather small. Still, you will come across these functions and therefore, it is good to know what is happening. Lambda functions are also called nameless functions or anonymous functions which describes them much better. A lambda function is an inline definition of a function which does not have a name. Apart from not having a name, what is the difference between a regular function and the lambda function? Practically nothing! When comparing the byte-code (code that is generated when Python is interpreting code) between the two types is identical. Then the next question is: why to use a lambda function when a regular function does the same thing? Indeed, most of the time, a regular function is the way to go. However, sometimes you only need to do a small operation only once. While you could still use a regular function, an inline function (the lambda function) could be somewhat easier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The definition of a lambda function is quite short: it starts with the lambda keyword followed by one or more parameters separated by commas. The steps of the function itself follow after a semicolon. Let's have a look at an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total costs: €190.7\n"
     ]
    }
   ],
   "source": [
    "some_list = [\n",
    "    ('dinner', 50.20),\n",
    "    ('present', 20.00),\n",
    "    ('ticket', 120.50)\n",
    "]\n",
    "\n",
    "total_costs = sum(map(lambda x: x[1], some_list))\n",
    "print(f'total costs: €{total_costs}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we have a list of expenses. Each expense is a tuple with a name and the costs. While there are other ways (like list comprehensions), we choose to use a map() to select all the costs. Map() expects a function and an iterable. We could now create a regular function that selects the second item of the tuple but we only use it once. This means that a lambda function would be perfect here. The map() executes our function on each tuple and returns a list of all the costs, followed by a sum. Now we have a look at some more examples (disclaimer: not all are useful):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello Dennis\n",
      "But just why?\n",
      "Byte code for the lambda function:\n",
      " 11           0 LOAD_FAST                0 (x)\n",
      "              2 LOAD_FAST                1 (y)\n",
      "              4 BINARY_ADD\n",
      "              6 RETURN_VALUE\n",
      "Byte code for the regular function:\n",
      " 14           0 LOAD_FAST                0 (x)\n",
      "              2 LOAD_FAST                1 (y)\n",
      "              4 BINARY_ADD\n",
      "              6 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "# We \"could\" assign a nameless function to a variable\n",
    "my_func = lambda x: print(f'hello {x}')\n",
    "my_func('Dennis')\n",
    "\n",
    "# or directly call the lambda\n",
    "(lambda x: print(f'But just {x}'))('why?')\n",
    "\n",
    "# compare the byte-code to show they are identical\n",
    "import dis  # module to inspect byte code\n",
    "\n",
    "add_lambda = lambda x, y: x + y\n",
    "\n",
    "def add_func(x, y):\n",
    "    return x + y\n",
    "\n",
    "print('Byte code for the lambda function:')\n",
    "dis.dis(add_lambda)\n",
    "print('Byte code for the regular function:')\n",
    "dis.dis(add_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example we show that a lambda expression returns a reference to the nameless function. As the function is now catched by a variable, it will not be 'garbage-collected'. This eliminates the benefit of the lambda function, namely a one-time nameless function, which will be disposed after its use. If you are add a reference to a lambda function, please write a regular function instead. Regular functions are much more readible. Nevertheless, you could catch the lambda function into a reference, and the variable then acts as a regular function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"assets/day21-lambda.jpg\" alt=\"Python Envs\"  width=\"600\" style=\"display: block; margin: 0 auto\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just for fun, you could also directly call the reference without catching it in a variable. While it does not make much sense it is possible and completely valid. The additional parenthesis are required or a function identifier is returned. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prove that regular functions and lambda functions are identical we can inspect the byte-code from the Python interpreter. For this, we can make use of the dis module, which visualizes the actual byte-code executed. All Python commands can be split down to a small number of byte-code operations. Here we compare the byte-code between the regular and the lambda and see that we have an exact match. They are identical in byte-code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summation of 1, 2, and 3 = 6\n",
      "All even numbers: [2, 4, 6, 8, 10]\n",
      "The sum of some_numbers: 55\n"
     ]
    }
   ],
   "source": [
    "# multiple parameters\n",
    "print('Summation of 1, 2, and 3 =', (lambda x, y, z: x + y + z) (1, 2, 3))\n",
    "\n",
    "# another interesting use: filter\n",
    "some_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "print('All even numbers:', list(filter(lambda x: x % 2 == 0, some_numbers)))\n",
    "\n",
    "# similar to other languages: reduce\n",
    "from functools import reduce\n",
    "print('The sum of some_numbers:', reduce(lambda x, y: x + y, some_numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The previous example shows two new formats which can be useful: filter() and reduce(). As the name suggests, filter() is used to filter an iterable. Each item of the iterable is put into a function that must return a boolean. If the boolean is true, the value is kept. If the boolean is false, the value is omitted. We can supply a regular function, but if it is a one-timer, a lambda functions can be useful.\n",
    "\n",
    "Reduce() is a method that is common in many other languages. It takes an iterable and uses the supplied function to reduce the iterable to a single value (of the same type). What is happening is that it takes the first two values of the iterable and creates a new value according to the function supplied. It repeats this operation until only a single value is left. Again, this could be a great spot for a lambda function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice for today:\n",
    "While a life without lambda functions is perfectly fine, I think it is a good nice to know. You will encounter them probably so now and then. In this assignment we will use reduce() to find the maximum value of a set of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "import random\n",
    "\n",
    "N = 1000  # amount of random values\n",
    "values = [random.random() * 100 for ix in range(N)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment:\n",
    "Use reduce to find the maximum of the 1000 values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hints:\n",
    "1. the lambda function has two parameters\n",
    "2. use the inline if to return the correct value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have any questions, feel free to contact me through [LinkedIn](https://www.linkedin.com/in/dennisbakhuis/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}