4. Comprehension, Map, Reduce, Filter, Lambda functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "302edfe8",
   "metadata": {},
   "source": [
    "# Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8412f7f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comprehensions are syntactic constructs that enable sequences to be built from other sequences in a clear and concise manner."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bbd4a7b",
   "metadata": {},
   "source": [
    "#### List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "ce390bbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [<the_expression> for <the_element> in <the_iterable>]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9415dd38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 5, 4, 6, 14]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [\"automobiles\", \"Honda\", \"Benz\", \"Suzuki\", \"Morris Garages\" ]\n",
    "l2 = []\n",
    "\n",
    "for i in l1 :\n",
    "    l2.append(len(i))\n",
    "    \n",
    "l2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "790e2f62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 5, 4, 6, 14]\n"
     ]
    }
   ],
   "source": [
    "# Example on list comprehension\n",
    "l1 = [\"automobiles\", \"Honda\", \"Benz\", \"Suzuki\", \"Morris Garages\" ]\n",
    "\n",
    "# Create a list consisting of length of each element from the above list\n",
    "l2 = [len(word) for word in l1]\n",
    "\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "183f0a80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "automobiles  -  11\n",
      "Honda  -  5\n",
      "Benz  -  4\n",
      "Suzuki  -  6\n",
      "Morris Garages  -  14\n"
     ]
    }
   ],
   "source": [
    "# iterating over l1 and l2 simultaneously\n",
    "\n",
    "for i,j in zip(l1,l2):\n",
    "    print(i, \" - \", j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c21b9f20",
   "metadata": {},
   "source": [
    "#### Dictionary comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cdd3f8f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'automobiles': 11, 'Honda': 5, 'Benz': 4, 'Suzuki': 6, 'Morris Garages': 14}\n"
     ]
    }
   ],
   "source": [
    "# Example on dictionary comprehension\n",
    "l1 = [\"automobiles\", \"Honda\", \"Benz\", \"Suzuki\", \"Morris Garages\" ]\n",
    "\n",
    "# Create a dictionary consisting of element and length of each element from the above list\n",
    "d = {i : len(i) for i in l1}\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee1748b7",
   "metadata": {},
   "source": [
    "#### Set Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9a9f7a30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word : aloertoila\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'a', 'e', 'i', 'o'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word = input(\"Enter a word : \")\n",
    "vowels = {i for i in word if i in \"aeiou\"}\n",
    "vowels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3f0ea7b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 15, 4, 8]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [10, 20, 30, 24, 18]\n",
    "L2 = [8, 14, 15, 20, 10]\n",
    "L3 = []\n",
    "for  i in range(len(L1)):\n",
    "    L3.append(L1[i] - L2[i])\n",
    "L3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "38ca991d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 15, 4, 8]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using list comprehension\n",
    "L1 = [10, 20, 30, 24, 18]\n",
    "L2 = [8, 14, 15, 20, 10]\n",
    "L3 = [L1[i] - L2[i] for i  in range(0, len(L1))]\n",
    "L3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c0908a3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 4, 4: 16, 6: 36, 8: 64, 10: 100, 12: 144, 14: 196, 16: 256, 18: 324, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "# Creating a dictionary consisting of even natural numbers as key and square of each element as value \n",
    "ordinary_dict ={}\n",
    "\n",
    "for i in range(2,21):\n",
    "    if i % 2 == 0:\n",
    "        ordinary_dict[i] = i**2\n",
    "\n",
    "print(ordinary_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8be948ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 4, 4: 16, 6: 36, 8: 64, 10: 100, 12: 144, 14: 196, 16: 256, 18: 324, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "# Using dictionary comprehension\n",
    "updated_dict = {i : i**2 for i in range(2,21) if i % 2 ==0}\n",
    "print(updated_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "602e9c4c",
   "metadata": {},
   "source": [
    "The expression inside the brackets first starts with the operation/output that you desire, and then loops and conditionals occur in the same order of the regular code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "55df5d33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5c86f033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter n: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a list comprehension containing the squares of the integers from 1 till n (including 1 and n), and print the list.  \n",
    "n = int(input(\"Enter n: \"))\n",
    "l = [i**2 for i in range(1,n+1)]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cb986ef4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['old', 'apple', 'item', 'euphoria']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the words that start with a vowel from a list input_list=[wood, old, apple, big, item, euphoria] using list comprehensions.\n",
    "\n",
    "l = ['wood','old','apple','big','item','euphoria']\n",
    "\n",
    "new_l = [ele for ele in l if ele[0] in 'aeiouAEIOU']\n",
    "new_l\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "af148ae5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 27,\n",
       " 6: 216,\n",
       " 9: 729,\n",
       " 12: 1728,\n",
       " 15: 3375,\n",
       " 18: 5832,\n",
       " 21: 9261,\n",
       " 24: 13824,\n",
       " 27: 19683,\n",
       " 30: 27000,\n",
       " 33: 35937,\n",
       " 36: 46656,\n",
       " 39: 59319,\n",
       " 42: 74088,\n",
       " 45: 91125,\n",
       " 48: 110592,\n",
       " 51: 132651,\n",
       " 54: 157464,\n",
       " 57: 185193,\n",
       " 60: 216000,\n",
       " 63: 250047,\n",
       " 66: 287496,\n",
       " 69: 328509,\n",
       " 72: 373248,\n",
       " 75: 421875,\n",
       " 78: 474552,\n",
       " 81: 531441,\n",
       " 84: 592704,\n",
       " 87: 658503,\n",
       " 90: 729000,\n",
       " 93: 804357,\n",
       " 96: 884736,\n",
       " 99: 970299}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a dictionary where the keys are multiples of 3 among the first 100 natural numbers and each value is the cube of the key.\n",
    "\n",
    "l =  list(range(1,101))\n",
    "dict = {ele: ele**3 for ele in l if ele%3 == 0}\n",
    "dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c1c1ee6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i+j for i in \"abc\" for j in \"def\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f7f09dd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'aaa', 'C': 'ccc', 'B': 'bbb', 'D': 'ddd'}\n"
     ]
    }
   ],
   "source": [
    "d = {x.upper(): x*3 for x in 'acbd'}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "772a2bbe",
   "metadata": {},
   "source": [
    "# Lambda functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7729d0ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lambda functions are another way of defining functions to execute small functionalities occurring while implementing a complex functionality. \n",
    "# These functions can take multiple parameters as input but can only execute a single expression; \n",
    "# in other words, they can only perform a single operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3418ad24",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function_name  = lambda <space>  input_parameters :  output_parameters "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fdc3e4f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'even'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a lambda function to check a number is even or odd\n",
    "f = lambda x: \"even\" if x % 2 == 0 else \"odd\"\n",
    "\n",
    "f(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "507e319d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "8\n",
      "8, 8 , maximum = 8\n"
     ]
    }
   ],
   "source": [
    "# Create a lambda function 'greater', which takes two arguments x and y and return x if x>y otherwise y.\n",
    "#If x = 2 and y= 3, then the output should be 3.\n",
    "x = int(input())\n",
    "y = int(input())\n",
    "maximum = lambda x,y : x if x>y else y\n",
    "print(\"{0}, {1} , maximum = {2}\".format(x,y,maximum(x,y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "694b9143",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9996"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minimum = (lambda x, y: x if x < y else y)\n",
    "minimum(101*99, 102*98)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6549a023",
   "metadata": {},
   "source": [
    "# Map functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4b9e094a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map is a function that works like list comprehensions and for loops. \n",
    "# It is used when you need to map or implement functions on various elements at the same time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "63bca40b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# map(function,iterable object)\n",
    "# The function here can be a lambda function or a function object.\n",
    "# The iterable object can be a string, list, tuple, set or dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8e00533b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'WOOD'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['wood','old','apple','big','item','euphoria']\n",
    "f = lambda x: x.upper()\n",
    "f(l[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1b066b6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "caps = []\n",
    "\n",
    "for word in l:\n",
    "    caps.append(f(word))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2b4b38a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['WOOD', 'OLD', 'APPLE', 'BIG', 'ITEM', 'EUPHORIA']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "eeffb9cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['WOOD', 'OLD', 'APPLE', 'BIG', 'ITEM', 'EUPHORIA']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: x.upper(), l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "69e21032",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x0000011779D70520>\n",
      "[4, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "L1 = [2,4,5]\n",
    "print(map(lambda x: x**2, L1))\n",
    "print(list(map(lambda x: x**2, L1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "90ff9464",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "def multi(x):\n",
    "    return x*2\n",
    "\n",
    "list_numbers = [1,2,3,4]\n",
    "sample_map = map(multi, list_numbers)\n",
    "\n",
    "print(list(sample_map))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c36be33",
   "metadata": {},
   "source": [
    "# Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d05e8206",
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter(function,iterable object)\n",
    "# The function object passed to the filter function should always return a boolean value.\n",
    "# The iterable object can be a string, list, tuple, set or dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef21a916",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "b6f07826",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "my_list = [3,4,5,6,7,8,9]\n",
    "\n",
    "divby3 = lambda x:  x % 3 == 0\n",
    "\n",
    "div = filter(divby3, my_list)\n",
    "print(list(div))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f42f8396",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Cornor', 19], ['Trump', 20]]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_data = {1:['Sam', 15] , 2:['Rob',18], 3:['Kyle', 16], 4:['Cornor',19], 5:['Trump',20]}\n",
    "l = list(filter(lambda x : x[1] > 18, students_data.values()))\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "680ffc0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list(filter(lambda x : x[1] > 18, students_data.values())))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17b5144e",
   "metadata": {},
   "source": [
    "# Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b027084c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reduce' is an operation that breaks down the entire process into pair-wise operations and \n",
    "# uses the result from each operation, with the successive element. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5344c58f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reduce(function,iterable object)\n",
    "\n",
    "# The function object passed to the reduce function decides what expression is passed to the iterable object.\n",
    "# The iterable object can be a string, list, tuple, set or dictionary.\n",
    "# Also, reduce function produces a single output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "7e6fce72",
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "9b79b757",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list(range(1,4))\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "15a5557c",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x, y: x*y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "54f7cd95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "q  = reduce(lambda x, y: x*y, range(1,4))\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "9b53217b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# Factorial\n",
    "\n",
    "l = list(range(1,6))\n",
    "q  = reduce(lambda x, y: x*y, l)\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "4f7f8eba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PaulTed'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "list_1 = ['Paul','Ted']\n",
    "reduce(lambda x,y: x + y,list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fd7ae42",
   "metadata": {},
   "source": [
    "# Practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "7cdf9c93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Santa Cruz True\n",
      "Santa fe True\n",
      "Mumbai False\n",
      "Delhi False\n",
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Using the function Map, count the number of words that start with ‘S’ in input_list.\n",
    "\n",
    "l = ['Santa Cruz','Santa fe','Mumbai','Delhi']\n",
    "f = lambda x: x.startswith('S')\n",
    "res = list(map(f, l))\n",
    "for i,j in zip(l,res):\n",
    "    print(i,j)\n",
    "\n",
    "print(sum(res))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "da236b24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "l = ['Santa Cruz','Santa fe','Mumbai','Delhi']\n",
    "f = lambda x: True if x[0]==\"S\" else False\n",
    "\n",
    "count = len(list(filter(f,l)))\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "815ba82a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ankur Narang', 'Avik Sarkar', 'Kiran R', 'Nitin Sareen']\n"
     ]
    }
   ],
   "source": [
    "# Create a list ‘name’ consisting of the combination of the first name and the second name from list 1 and 2 respectively. \n",
    "\n",
    "str= [ ['Ankur', 'Avik', 'Kiran', 'Nitin'], ['Narang', 'Sarkar', 'R', 'Sareen']]\n",
    "first_name = str[0]\n",
    "last_name = str[1]\n",
    "l = []\n",
    "for i,j in zip(first_name,last_name ):\n",
    "    name = i+\" \"+j\n",
    "    l.append(name)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "793977cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ankur Narang', 'Avik Sarkar', 'Kiran R', 'Nitin Sareen']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x,y: x+' '+y\n",
    "list(map(f,first_name,last_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "38af95c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10, 15, 20, 25, 30, 35, 40, 45, 50]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract a list of numbers that are multiples of 5 from a list of integers named input_list.\n",
    "inp = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]\n",
    "\n",
    "f = lambda x: x%5==0\n",
    "list(filter(f,inp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "a48fe548",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['salsap']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You are given a list of strings such as input_list = ['hdjk', 'salsap', 'sherpa'].\n",
    "# Extract a list of names that start with an ‘s’ and end with a ‘p’ (both 's' and 'p' are lowercase) in input_list.\n",
    "\n",
    "inp = ['hdjk', 'salsap', 'sherpa']\n",
    "\n",
    "f = lambda x: x.startswith('s') and x.endswith('p')\n",
    "list(filter(f,inp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "f775441d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I Love Python'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using the Reduce function, concatenate a list of words in input_list, and print the output as a string.\n",
    "#If input_list = ['I','Love','Python'], the output should be the string 'I Love Python'.\n",
    "\n",
    "input_list = ['I','Love','Python']\n",
    "\n",
    "from functools import reduce\n",
    "f = lambda x,y :x+' '+y\n",
    "reduce(f, input_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "36315cd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I Love Python'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x,y: x + \" \" +y, input_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "6f445c65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You are given a list of numbers such as input_list = [31, 63, 76, 89]. \n",
    "# Find and print the largest number in input_list using the reduce() function.\n",
    "\n",
    "input_list = [31, 63, 76, 89]\n",
    "f= lambda x,y: max(x,y)\n",
    "reduce(f,input_list)"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}