Lambda and Currying

Author: sanketsarang

Lesson 8 - Functions.ipynb

@@ -4,6 +4,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "[<img src=\"http://cloud.blobcity.net/assets/images/badge.png\" height=\"20\" style=\"margin-bottom:-15px\" />](https://cloud.blobcity.com/#/ps/shared-cloudbook/66c4fcaa-b0e4-4e0a-b275-49cdf007667a)\n",
+    "\n",
     "# Functions\n",
     "\n",
     "Functions are one of the most important parts of Python. Like any other language they allow to create re-usable components of code. But functions in Python are special. They are essentially objects in themselves and can be passed around as parameters. We will take a look at this in detail in the later parts of this module. \n",
@@ -722,7 +724,178 @@
     "``` python\n",
     "process3() # defaults to process3(num)\n",
     "process3(num) # same as above\n",
-    "```"
+    "```\n",
+    "\n",
+    "## Lambda Functions\n",
+    "\n",
+    "These are also called anonymous functions. This is a way of writing functions in a single statement. The result of the function can be a non `None` return value. We use the keyword `lambda` to define a lambda function. \n",
+    "\n",
+    "In the previous seciton, we had defined a square function as\n",
+    "\n",
+    "``` python\n",
+    "def square(x): \n",
+    "    return x*x\n",
+    "```\n",
+    "\n",
+    "By using a lambda function, we can define this function in a single line as shown below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "square = lambda x: x * x\n",
+    "\n",
+    "print(square(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Whether we define the `square` function using the `def` keyword, or `lambda` keyword, they both produce exactly the same function.\n",
+    "\n",
+    "So why have `lambda` functions? \n",
+    "\n",
+    "In simpliest forms, they make programs more elegant. It involves lesser typing for coders, but in some scenarious where you want to pass a short function as a parameter, it is much more convenient to make an inline definition of a lambda function than have a full blown function imlementation. \n",
+    "\n",
+    "Let's take a look at how our `process3` function would work if we were to use a lambda function. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n",
+      "27\n"
+     ]
+    }
+   ],
+   "source": [
+    "def process3(func):\n",
+    "    print(func(3))\n",
+    "    \n",
+    "process3(lambda x: x * x)\n",
+    "process3(lambda x: x * x * x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is much shorter code is it not?\n",
+    "\n",
+    "Over here, we did not define a function called `square` and a function called `cube`. Rather we put the logic as a lambda function while invoking the `process3` function itself. \n",
+    "\n",
+    "Now, we could also write the above code in a more elegant manner as shown below. Nice uh?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n",
+      "27\n"
+     ]
+    }
+   ],
+   "source": [
+    "process3 = lambda func: print(func(3))\n",
+    "process3(lambda x: x * x)\n",
+    "process3(lambda x: x * x * x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Currying Functions\n",
+    "\n",
+    "Currying functions is a concept that allows us to create additional functions from existing functions. It involves partially applying arguents to the function to create a new function. Lets take a look at an example to understand this best. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "def sum(a,b):\n",
+    "    return a + b\n",
+    "\n",
+    "print(sum(1,2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The above function is very simple, and simply does the sumation of the two numbers passed as parameter. But what if we wanted to create a function that adds 10 to any number that is passed as a parameter to it. \n",
+    "\n",
+    "We can create a new function that looks like this\n",
+    "\n",
+    "``` python\n",
+    "def sum(a):\n",
+    "    return a + 10\n",
+    "```\n",
+    "\n",
+    "Or we can use the previously defined `sum` function, by creating a curried function. Let's see how we do this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "15\n"
+     ]
+    }
+   ],
+   "source": [
+    "addTen = lambda a: sum(a, 10)\n",
+    "\n",
+    "print(addTen(5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In a single line, we defined a new function called `addTen` that partially applies an argument to an already existent function `sum`. We have fix the value of `b = 10` when creating the curried function `addTen`.\n",
+    "\n",
+    "In this case the first argument `a` to the function `sum` is said to be currier, and the resulting function `addTen` is said to be a curried function."
    ]
   }
  ],