07_anonymous_or_lambda_function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In Python, anonymous function is a function that is defined without a name.\n",
    "- A simple one line function\n",
    "- We don't use `def` and `return` as they are implicit\n",
    "- short, sweet and easy to implement\n",
    "- Python supports the creation of anonymous functions (i.e. functions that are not bound to a name) at runtime, using a construct called \"lambda\".\n",
    "- Often used in conjunction with typical functional concepts like filter() and map().\n",
    "\n",
    "Syntax:\n",
    "```python\n",
    "lambda arguments: expression\n",
    "```\n",
    "\n",
    "Let's consider a function that returns square of a value\n",
    "```python\n",
    "def squared(x):\n",
    "    return x*x\n",
    "```\n",
    "\n",
    "Now, the same function can be made one-liner, usin lambda\n",
    "```python\n",
    "lambda x: x*x\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squared(x=10):\n",
    "    return x*x\n",
    "\n",
    "print(\"function: \", squared(5))\n",
    "\n",
    "sq = lambda x=10: x*x\n",
    "print(\"Lambda:\", sq(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple parameters\n",
    "addition = lambda x, y: x+y\n",
    "addition(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can use if else as well inside the lambda function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def maximum(x, y):\n",
    "    if x > y:\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "maximum(7,19)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maximum = lambda x, y: x if x > y else y\n",
    "maximum(3,123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "div = lambda x, y: x/y if y!=0 else \"zero division errer\"\n",
    "div(4,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- using `map` function, we can apply same function to each element of a sequence\n",
    "- returns the modified list\n",
    "- Basic syntax : \n",
    "```python \n",
    "map(func, seq)\n",
    "```\n",
    "- The first argument `func` is the name of a function and the second a sequence (e.g. a list) seq. \n",
    "- `map()` applies the function `func` to all the elements of the sequence `seq`. It returns a new list with the elements changed by `func`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[97.7, 98.60000000000001, 99.5, 102.2]\n",
      "[2.5, 2.7777777777777777, 3.055555555555556, 3.8888888888888893]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "def fahrenheit(T):\n",
    "    return ((float(9)/5)*T + 32)\n",
    "def celsius(T):\n",
    "    return (float(5)/9)*(T-32)\n",
    "\n",
    "temp = (36.5, 37, 37.5,39)\n",
    "\n",
    "F = map(fahrenheit, temp)\n",
    "C = map(celsius, temp)\n",
    "print(list(F))\n",
    "print(list(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** can be used with lambda **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print(list(map(lambda x: x**2, n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- filter item out of sequence\n",
    "- returned filtered list\n",
    "- The function `filter(function, list)` offers an elegant way to filter out all the elements of a list, for which the function function returns `True`.\n",
    "- The function `filter(f,l)` needs a function `f` as its first argument. f returns a Boolean value, i.e. either True or False. \n",
    "- This function will be applied to every element of the list l. Only if f returns True will the element of the list be included in the result list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print(tuple(filter(lambda x: x>2, n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib = [0,1,1,2,3,5,8,13,21,34,55]\n",
    "result = filter(lambda x: x % 2 == 0, fib)\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduce function\n",
    "- returns item, not a list\n",
    "- result of first operation is the input to next operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example: Addition of each values in the list\n",
    "from functools import reduce\n",
    "nums= [47, 11, 42, 13]\n",
    "final_val = reduce(lambda x,y: x+y, nums)\n",
    "final_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}