Functions_cx.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "69c8406f",
   "metadata": {},
   "source": [
    "#### Let's create a function(with docstring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12d96e18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_even(num):\n",
    "    \"\"\"This function returns if a given number is odd or even\n",
    "    input- any valid integer\n",
    "    output- odd/even\n",
    "    created on- 12th July 2023\n",
    "    \"\"\"\n",
    "    if type(num) == int:\n",
    "        if num % 2== 0:\n",
    "            return 'even'\n",
    "        else:\n",
    "            return 'odd'\n",
    "    else:\n",
    "        return 'Format not valid!!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d21568ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odd\n",
      "even\n",
      "odd\n",
      "even\n",
      "odd\n",
      "even\n",
      "odd\n",
      "even\n",
      "odd\n",
      "even\n"
     ]
    }
   ],
   "source": [
    "# function \n",
    "# function_name(input)\n",
    "for i in range(1,11):\n",
    "    x = is_even(i)\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bced08c",
   "metadata": {},
   "source": [
    "#### 2 Point of views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "396edcb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Format not valid!!'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_even('hello')          # senior vs junior programmer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba3cdb7",
   "metadata": {},
   "source": [
    "### Parameter vs argument\n",
    "\n",
    " Parameter is the thing that we created at begining\n",
    " Argument is that on which you put the value\n",
    " for eg in phone brightness setting is parameter but when we give a value to it, it became argument"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0be07931",
   "metadata": {},
   "source": [
    "### Types of arguments\n",
    "-> Default Argument\n",
    "-> Positional Argument\n",
    "-> Keyword Argument\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "42cc4f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(a,b):\n",
    "    return a**b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "941bfec6",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "power() missing 1 required positional argument: 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[11], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mpower\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: power() missing 1 required positional argument: 'b'"
     ]
    }
   ],
   "source": [
    "power(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "45369a62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to overcome this we make changes by giving default argument\n",
    "def power(a=1,b=1):\n",
    "    return a**b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d70e4ea8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7142b39b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Positonal argument\n",
    "power(2,3)   #first value given to a and second to b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "925e2888",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Keyword argument you can pass arguments by giving names\n",
    "power(b=3,a=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ceda2c9",
   "metadata": {},
   "source": [
    "```*args and  **kwargs```\n",
    "*args and *kwargs are special Python Keywords that are used to pass the varaible length of arguments to a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0caf57de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# *args\n",
    "# allows us to pass a variable number of non-keyword arguments to a function.\n",
    "def multiply(*args):\n",
    "    product = 1\n",
    "    \n",
    "    for i in args:\n",
    "        product = product * i\n",
    "        \n",
    "    return product    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "146badc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40320"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(1,2,3,4,5,6,7,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d06cb954",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply(*kwargs):\n",
    "  product = 1\n",
    "\n",
    "  for i in kwargs:\n",
    "    product = product * i\n",
    "\n",
    "  print(kwargs)\n",
    "  return product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f10df8b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "43545600"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(1,2,3,4,5,6,7,8,9,10,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e9abc2fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# **kwargs\n",
    "# **kwargs allows us to pass any number of keyword arguments.\n",
    "# Keyword arguments mean that they contain a key-value pair, like a Python dictionary.\n",
    "\n",
    "def display(**salman):\n",
    "\n",
    "  for (key,value) in salman.items():\n",
    "    print(key,'->',value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e17e52ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "india -> delhi\n",
      "srilanka -> colombo\n",
      "nepal -> kathmandu\n",
      "pakistan -> islamabad\n"
     ]
    }
   ],
   "source": [
    "display(india='delhi',srilanka='colombo',nepal='kathmandu',pakistan='islamabad')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec3b77c",
   "metadata": {},
   "source": [
    "##### Points to remember while using `*args and **kwargs`\n",
    "\n",
    "- order of the arguments matter(normal -> `*args` -> `**kwargs`)\n",
    "- The words “args” and “kwargs” are only a convention, you can use any name of your choice\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "040ab118",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function returns if a given number is odd or even\n",
      "    input- any valid integer\n",
      "    output- odd/even\n",
      "    created on- 12th July 2023\n",
      "    \n",
      "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "\n",
      "Prints the values to a stream, or to sys.stdout by default.\n",
      "Optional keyword arguments:\n",
      "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "sep:   string inserted between values, default a space.\n",
      "end:   string appended after the last value, default a newline.\n",
      "flush: whether to forcibly flush the stream.\n"
     ]
    }
   ],
   "source": [
    "print(is_even.__doc__)   # to see the documentation of a function\n",
    "print(print.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b79d65d9",
   "metadata": {},
   "source": [
    "### How function memory is allocated "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fae0045f",
   "metadata": {},
   "source": [
    "https://pythontutor.com/render.html#mode=display \n",
    "see this using this website"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c032f6",
   "metadata": {},
   "source": [
    "### Without return statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4b737a8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3]\n",
    "print(L.append(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "29aa9e97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3]\n",
    "print(L.append(4))\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5315aad6",
   "metadata": {},
   "source": [
    "### Variable Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74ef1632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def g(y):\n",
    "    print(x)\n",
    "    print(x+1)\n",
    "x = 5\n",
    "g(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2d2d9e5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def f(y):\n",
    "    x = 1\n",
    "    x += 1\n",
    "    print(x)\n",
    "x = 5\n",
    "f(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "66166f08",
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[5], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m     x \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m      3\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[1;32m----> 4\u001b[0m \u001b[43mh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n",
      "Cell \u001b[1;32mIn[5], line 2\u001b[0m, in \u001b[0;36mh\u001b[1;34m(y)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mh\u001b[39m(y):\n\u001b[1;32m----> 2\u001b[0m     x \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "def h(y):\n",
    "    x += 1\n",
    "x = 5\n",
    "h(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "074e3688",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in f(x): x = 4\n",
      "in main program scope: z = 4\n",
      "in main program scope: x = 3\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "   x = x + 1\n",
    "   print('in f(x): x =', x)\n",
    "   return x\n",
    "\n",
    "x = 3\n",
    "z = f(x)\n",
    "print('in main program scope: z =', z)\n",
    "print('in main program scope: x =', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b53ab7c5",
   "metadata": {},
   "source": [
    "## Nested function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2aa5db3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "  def g():\n",
    "    print('inside function g')\n",
    "    f()\n",
    "  g()\n",
    "  print('inside function f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5eda09ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6990fd72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in g(x): x = 4\n"
     ]
    }
   ],
   "source": [
    "def g(x):\n",
    "    def h():\n",
    "        x = 'abc'\n",
    "    x = x + 1\n",
    "    print('in g(x): x =', x)\n",
    "    h()\n",
    "    return x\n",
    "\n",
    "x = 3\n",
    "z = g(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c5e1728",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in g(x): x =  4\n",
      "in h(x): x =  5\n",
      "in main program scope: x =  3\n",
      "in main program scope: z =  4\n"
     ]
    }
   ],
   "source": [
    "def g(x):\n",
    "    def h(x):\n",
    "        x = x+1\n",
    "        print(\"in h(x): x = \", x)\n",
    "    x = x + 1\n",
    "    print('in g(x): x = ', x)\n",
    "    h(x)\n",
    "    return x\n",
    "\n",
    "x = 3\n",
    "z = g(x)\n",
    "print('in main program scope: x = ', x)\n",
    "print('in main program scope: z = ', z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e928942",
   "metadata": {},
   "source": [
    "## Functions are first class citizens\n",
    "i.e. they are considered as a datatype on which we can do any operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d75f158c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1943712322832"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# type and id\n",
    "def square(num):\n",
    "    return num**2\n",
    "\n",
    "type(square)\n",
    "id(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dfdf0225",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reassign\n",
    "x = square\n",
    "id(x)\n",
    "x(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "690da45f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# deleting a function\n",
    "del square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4635a720",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'square' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43msquare\u001b[49m(\u001b[38;5;241m3\u001b[39m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'square' is not defined"
     ]
    }
   ],
   "source": [
    "square(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "195286ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# storing\n",
    "L = [1,2,3,4,square]\n",
    "L[-1](3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fbf69daa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<function __main__.square(num)>}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = {square}\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "997cbbde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# returning a function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "65105fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    def x(a, b):\n",
    "        return a+b\n",
    "    return x\n",
    "    \n",
    "val = f()(3,4)\n",
    "print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6c58113d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function as argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c34484b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside func_c\n",
      "inside func_a\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def func_a():\n",
    "    print('inside func_a')\n",
    "\n",
    "def func_b(z):\n",
    "    print('inside func_c')\n",
    "    return z()\n",
    "\n",
    "print(func_b(func_a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69285c3",
   "metadata": {},
   "source": [
    "## Lambda Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "107d1958",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x -> x^2\n",
    "lambda x:x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "586ec236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x,y -> x+y\n",
    "a = lambda x,y:x+y\n",
    "a(5,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e866e036",
   "metadata": {},
   "source": [
    "#### Diff between lambda vs Normal Function\n",
    "\n",
    "- No name\n",
    "- lambda has no return value(infact,returns a function)\n",
    "- lambda is written in 1 line\n",
    "- not reusable\n",
    "\n",
    "Then why use lambda functions?<br>\n",
    "**They are used with HOF**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0760b710",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if a string has 'a'\n",
    "a = lambda s:'a' in s\n",
    "a('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4461b750",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'even'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# odd or even\n",
    "a = lambda x:'even' if x%2 == 0 else 'odd'\n",
    "a(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "107c5149",
   "metadata": {},
   "source": [
    "### Higher Order Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0a9cd9db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 27, 64, 125]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "def square(x):\n",
    "  return x**2\n",
    "\n",
    "def cube(x):\n",
    "  return x**3\n",
    "\n",
    "# HOF\n",
    "def transform(f,L):\n",
    "  output = []\n",
    "  for i in L:\n",
    "    output.append(f(i))\n",
    "\n",
    "  print(output)\n",
    "\n",
    "L = [1,2,3,4,5]\n",
    "\n",
    "transform(lambda x:x**3,L)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a05678cf",
   "metadata": {},
   "source": [
    "### Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a1e474e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# square the items of a list\n",
    "list(map(lambda x:x**2,[1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c10d83bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['odd', 'even', 'odd', 'even', 'odd']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# odd/even labelling of list items\n",
    "L = [1,2,3,4,5]\n",
    "list(map(lambda x:'even' if x%2 == 0 else 'odd',L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "81c002e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['male', 'male', 'female']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fetch names from a list of dict\n",
    "\n",
    "users = [\n",
    "    {\n",
    "        'name':'Rahul',\n",
    "        'age':45,\n",
    "        'gender':'male'\n",
    "    },\n",
    "    {\n",
    "        'name':'Nitish',\n",
    "        'age':33,\n",
    "        'gender':'male'\n",
    "    },\n",
    "    {\n",
    "        'name':'Ankita',\n",
    "        'age':50,\n",
    "        'gender':'female'\n",
    "    }\n",
    "]\n",
    "\n",
    "list(map(lambda users:users['gender'],users))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f30fe14d",
   "metadata": {},
   "source": [
    "### Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "104da5a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# numbers greater than 5\n",
    "L = [3,4,5,6,7]\n",
    "\n",
    "list(filter(lambda x:x>5,L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e4ba37e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fetch fruits starting with 'a'\n",
    "fruits = ['apple','guava','cherry']\n",
    "\n",
    "list(filter(lambda x:x.startswith('a'),fruits))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75203aae",
   "metadata": {},
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4df4e6a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum of all item\n",
    "import functools\n",
    "\n",
    "functools.reduce(lambda x,y:x+y,[1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "755cf137",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find min\n",
    "functools.reduce(lambda x,y:x if x>y else y,[23,11,45,10,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4bcadd7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}