LambdaFunctionPythonFile.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8c80cbee",
   "metadata": {},
   "source": [
    "## Lambda function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14dc472d",
   "metadata": {},
   "source": [
    "### 1.\tWrite a  Python program to create a lambda function that adds 15 to a given number passed in as an argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c187bc",
   "metadata": {},
   "source": [
    "#### Ans 1) Steps:\n",
    "- Use the synstax : ` lambda  argument : expression `\n",
    "- argument is nothing just an input number that a user pass to this function.\n",
    "- In expression add 15 to given number/input.\n",
    "- Create an object of this function (or simply we can say store into a variable).\n",
    "- Take the number from the user.\n",
    "- Call the lambda function using its object and pass the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7b6bb651",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A lambda function that adds 15 to given number.\n",
      "Enter a number to add 15 into it : 5\n",
      "Result after adding 15 to given number :  20\n"
     ]
    }
   ],
   "source": [
    "print(\"A lambda function that adds 15 to given number.\")\n",
    "## create lambda funciton\n",
    "func = lambda number : number + 15\n",
    "\n",
    "## take value from user\n",
    "num = int(input(\"Enter a number to add 15 into it : \"))\n",
    "\n",
    "## call the function\n",
    "print(\"Result after adding 15 to given number : \",func(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9b516e2",
   "metadata": {},
   "source": [
    "### 2.\tCreate a lambda function that multiplies argument x with argument y and prints the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ef85bb4",
   "metadata": {},
   "source": [
    "#### Ans 2) Steps:\n",
    "- Use the synstax : ` lambda  argument1,argumnet2 : expression `\n",
    "- argument1 is x and argument2 is y.\n",
    "- In expression mutliply them.\n",
    "- Create an object of this function (or simply we can say store into a variable).\n",
    "- Take the value of x and y from the user.\n",
    "- Call the lambda function using its object and pass the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4f7dfeef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A lambda function that takes two numbers as argument and return their product.\n",
      "Enter the value of x : 10\n",
      "Enter the value of y : 5\n",
      "Result of multiplication of x and y is :  50\n"
     ]
    }
   ],
   "source": [
    "print(\"A lambda function that takes two numbers as argument and return their product.\")\n",
    "## create lambda funciton\n",
    "func2 = lambda x,y : x*y\n",
    "\n",
    "## take value from user\n",
    "num1 = int(input(\"Enter the value of x : \"))\n",
    "num2 = int(input(\"Enter the value of y : \"))\n",
    "\n",
    "\n",
    "## call the function\n",
    "print(\"Result of multiplication of x and y is : \", func2(num1,num2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "974796ab",
   "metadata": {},
   "source": [
    "### 3.\tWrite a  Python program that multiplies each number in a list with a given number using lambda functions. Print the results.\n",
    "input : list = [2, 4, 6, 9, 11] ,\n",
    "Given number = 2  ; \n",
    "output :\n",
    "4 8 12 18 22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1e0b1e0",
   "metadata": {},
   "source": [
    "#### Ans 3) \n",
    "1. Task : multiply given number with each element of the list.\n",
    "2. Approach : first Write the code to multiply only single element with given number, then call this function for each item of the list and print the result.\n",
    "\n",
    "#### Steps:\n",
    "- Use the synstax : ` lambda  argument : expression `.\n",
    "- argument is element of list.\n",
    "- In expression mutliply element with given number.\n",
    "- Create an object of this function.\n",
    "- Iterate through each elment of the list using for loop.\n",
    "- Call the lambda function using its object and pass the input and print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "923134e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list and number :  [2, 4, 6, 9, 11]  , 2\n",
      "Output after multiplying each element with 2 : \n",
      "4 8 12 18 22 "
     ]
    }
   ],
   "source": [
    "## given list and number\n",
    "lis = [2,4,6,9,11]\n",
    "num = 2\n",
    "print(\"Given list and number : \",lis,' ,',num)\n",
    "\n",
    "## create a lambda function\n",
    "fun3 = lambda x : x*num\n",
    "\n",
    "## iterating through each element of list and calling the lambda funciton and printing the result.\n",
    "print(\"Output after multiplying each element with 2 : \")\n",
    "for ele in lis:\n",
    "    print(fun3(ele),end= ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "408312d5",
   "metadata": {},
   "source": [
    "### 4.\tWrite a  Python program to find if a given string starts with a given character using Lambda."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a44f8b9e",
   "metadata": {},
   "source": [
    "#### Ans 4) Steps:\n",
    "- Use the synstax : ` lambda  argument : expression `\n",
    "- argument is string.\n",
    "- In expression we can use string's `startswith()` method to check wether given string starts with a given character or not.\n",
    "- `startswith()` method takes character as input and return True or False as output.\n",
    "- Create an object of this function.\n",
    "- Take string and character from the user.\n",
    "- Call the lambda function using its object , pass the input and print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "443a58e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function checks whether a given string starts with given character or not ?\n",
      "Enter the string : noorain\n",
      "Enter the character : n\n",
      "Result :  True\n"
     ]
    }
   ],
   "source": [
    "print(\"This function checks whether a given string starts with given character or not ?\")\n",
    "## taking the input from user\n",
    "input_String = input(\"Enter the string : \")\n",
    "input_character = input(\"Enter the character : \")\n",
    "\n",
    "## creating lambda function\n",
    "func4 = lambda s : s.startswith(input_character)\n",
    "\n",
    "## call the function and pass the string and display the result : \n",
    "print(\"Result : \", func4(input_String))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef1a3ba",
   "metadata": {},
   "source": [
    "### 5.\tWrite a  Python program to check whether a given string is a number or not using Lambda."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fe146c6",
   "metadata": {},
   "source": [
    "#### Ans 5) Steps:\n",
    "- Use the synstax : ` lambda  argument : expression `\n",
    "- argument is string.\n",
    "- In expression we can use string's `isdigit()` method to check wether given string is a number or not.\n",
    "- `isdigit()` returns True if string is digit else False.\n",
    "- Create an object of this function.\n",
    "- Take string from the user.\n",
    "- Call the lambda function using its object , pass the input and print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3016750",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function checks whether a given string is a number or not ?\n",
      "Enter the string : 123\n",
      "Result :  True\n"
     ]
    }
   ],
   "source": [
    "print(\"This function checks whether a given string is a number or not ?\")\n",
    "## taking the input from user\n",
    "input_String = input(\"Enter the string : \")\n",
    "\n",
    "## creating lambda function\n",
    "func5 = lambda s : s.isdigit()\n",
    "\n",
    "## call the function and pass the string and display the result : \n",
    "print(\"Result : \", func5(input_String))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e046991d",
   "metadata": {},
   "source": [
    "### 6.\tWrite a  Python program to find the intersection of two given arrays using Lambda.\n",
    "ex - list1 = [1, 2, 3, 5, 7, 8, 9, 10], \n",
    "list2 = [1, 2, 4, 8, 9],\n",
    "Intersection = [1, 2, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72aeae01",
   "metadata": {},
   "source": [
    "#### Ans 6) Steps:\n",
    "- Use the synstax : ` lambda  argument1,argument2 : expression `\n",
    "- argument1 is list1 and argument2 is list2.\n",
    "- In expression convert the both lists into set and use the set's `intersection()` method to find the intersection between both lists.\n",
    "- Create an object of this function.\n",
    "- Call the lambda function using its object , pass the input and print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "09dba10e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lists : \n",
      "List1 : [1, 2, 3, 5, 7, 8, 9, 10] \n",
      "List2 : [1, 2, 4, 8, 9]\n",
      "Intersection of given lists :  [8, 1, 2, 9]\n"
     ]
    }
   ],
   "source": [
    "## given lists\n",
    "lis1 = [1, 2, 3, 5, 7, 8, 9, 10] \n",
    "lis2 = [1, 2, 4, 8, 9]\n",
    "print(f\"Given lists : \\nList1 : {lis1} \\nList2 : {lis2}\")\n",
    "\n",
    "## creating the function\n",
    "fun6 = lambda lis1, lis2 : set(lis1).intersection(set(lis2))\n",
    "\n",
    "## call the function and pass the both lists\n",
    "print(\"Intersection of given lists : \",list(fun6(lis1,lis2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f1743d3",
   "metadata": {},
   "source": [
    "### 7.\tWrite a  Python program to find numbers divisible by nineteen or thirteen from a list of numbers using Lambda.\n",
    "list = [19, 65, 57, 39, 152, 639, 121, 44, 90, 190] ; \n",
    "output = [19, 65, 57, 39, 152, 190]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97b6eee3",
   "metadata": {},
   "source": [
    "#### Ans 7) Steps:\n",
    "- Use the synstax : ` lambda  argument: expression `\n",
    "- argument is number.\n",
    "- In expression check whether number is divisible by 13 or 19 or not without using if else.\n",
    "- Create an object of this function.\n",
    "- Create an empyt list to store the elements which are divisible by 13 or 19.\n",
    "- Iterate through the list of element and call the function, if function returns true then append the number into empty list.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9f3c2724",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input list :  [19, 65, 57, 39, 152, 639, 121, 44, 90, 190]\n",
      "Output list :  [19, 65, 57, 39, 152, 190]\n"
     ]
    }
   ],
   "source": [
    "## creating a lambda function that takes a number and return true if number is divisible by 13 or 19 else false.\n",
    "func7 = lambda num : ((num%13 == 0) or (num%19 == 0))\n",
    "\n",
    "## input list\n",
    "lis7 = [19, 65, 57, 39, 152, 639, 121, 44, 90, 190]\n",
    "print(\"Input list : \", lis7)\n",
    "\n",
    "## creating an empty list to store the numbers which are divisible by 13 or 19.\n",
    "templist = []\n",
    "\n",
    "## iterating through elements of list and calling the lambda function, if output of lambda function true then append the element\n",
    "## into empty list and finally print that empyt list.\n",
    "for num in lis7:\n",
    "    if func7(num):\n",
    "        templist.append(num)\n",
    "        \n",
    "print(\"Output list : \",templist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b40ad7d",
   "metadata": {},
   "source": [
    "### 8.\tWrite a  Python program to find palindromes in a given list of strings using Lambda.\n",
    "list of strings:['php', 'w3r', 'Python', 'abcd', 'Java', 'aaa'] , List of palindromes:['php', 'aaa']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "877ac369",
   "metadata": {},
   "source": [
    "#### Ans 8) Steps:\n",
    "- Use the synstax : ` lambda  argument: expression `\n",
    "- argument is string.\n",
    "- In expression check whether string is palindrome or not.\n",
    "- Create an object of this function.\n",
    "- Create an empty list to store the strings which are palindrome.\n",
    "- Iterate through the list of strings and call the function, if function returns true then append the string into empty list.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b2376861",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input list :  ['php', 'w3r', 'Python', 'abcd', 'Java', 'aaa']\n",
      "Output list :  ['php', 'aaa']\n"
     ]
    }
   ],
   "source": [
    "## creating a lambda function that takes a number and return true if number is divisible by 13 or 19 else false.\n",
    "func8 = lambda s : (s == s[::-1])\n",
    "\n",
    "## input list\n",
    "lis8 = ['php', 'w3r', 'Python', 'abcd', 'Java', 'aaa']\n",
    "print(\"Input list : \", lis8)\n",
    "\n",
    "## creating an empty list to store the strings which are palindromic.\n",
    "templist = []\n",
    "\n",
    "## iterating through elements of list and calling the lambda function, if output of lambda function true then append the element\n",
    "## into empty list and finally print that empyt list.\n",
    "for string in lis8:\n",
    "    if func8(string):\n",
    "        templist.append(string)\n",
    "        \n",
    "print(\"Output list : \",templist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c35bf27",
   "metadata": {},
   "source": [
    "### 9.\tWrite a  Python program to check whether a specified list is sorted or not using lambda.\n",
    "list:[1, 2, 4, 6, 8, 10, 12, 14, 16, 17] ; output : True , \n",
    "list:[10, 2, 4, 60, 8, 12, 14, 16, 17] ; output : False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f9acd47",
   "metadata": {},
   "source": [
    "#### Ans 9) Steps:\n",
    "- Use the synstax : ` lambda  argument: expression `\n",
    "- argument is list.\n",
    "- In expression check whether given list is equals to sorted list or not.\n",
    "- Create an object of this function.\n",
    "- Take a list.\n",
    "- Make a copy of the list and store into another variable.\n",
    "- sort the elements of list.\n",
    "- Using the lambda function check weather given list is equals to sorted list or not?\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1caa085f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is :  [1, 2, 4, 6, 8, 10, 12, 14, 16, 17]\n",
      "output : True\n"
     ]
    }
   ],
   "source": [
    "## given list \n",
    "lis9 = [1, 2, 4, 6, 8, 10,12, 14, 16, 17]\n",
    "print(\"Given list is : \", lis9)\n",
    "\n",
    "## make a copy of original list into another variable and sort it\n",
    "liscopy = lis9.copy()\n",
    "liscopy.sort()\n",
    "\n",
    "## write the lambda function to check weather given list is equal/same as sorted list or not.\n",
    "func9 = lambda lis : lis == liscopy\n",
    "\n",
    "if func9(lis9) :\n",
    "    print(\"output : True\")\n",
    "else:\n",
    "    print(\"output : False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e28efdf",
   "metadata": {},
   "source": [
    "###  10.\tWrite a  Python program to extract a specified size of strings from a given list of string values using lambda.\n",
    "list : [' Python', 'list', 'exercises', 'practice', 'solution'] , \n",
    "length of the string to extract : 8 , \n",
    "After extracting strings of specified length : ['practice', 'solution']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c895850",
   "metadata": {},
   "source": [
    "#### Ans 10) Steps:\n",
    "- Take a list of strings and length of string to be extracted.\n",
    "- Use the synstax : ` lambda  argument: expression `\n",
    "- argument is string.\n",
    "- In expression check whether the length of string is equal to given length.\n",
    "- Create an object of this function.\n",
    "- Iterate through each element of list and call the lambda function for each element, if output of function is True then store that string into list. Do all these steps using list comprehension.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "436ccda4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function extract the string of specific length \n",
      "Input list and length :  [' Python', 'list', 'exercises', 'practice', 'solution'] ,  8\n",
      "List of Extracted strings of length 8 :  ['practice', 'solution']\n"
     ]
    }
   ],
   "source": [
    "print(\"This function extract the string of specific length \")\n",
    "lis10 = [' Python', 'list', 'exercises', 'practice', 'solution']\n",
    "length = 8\n",
    "print(\"Input list and length : \",lis10 , ', ',length)\n",
    "\n",
    "## creating lambda function\n",
    "fun10 = lambda s : len(s) == length\n",
    "\n",
    "## creating a list of extracting strings by iterating through each element and calling the lambda function\n",
    "final_list = [ele    for ele in lis10   if fun10(ele)]\n",
    "\n",
    "## printing the final output\n",
    "print(f\"List of Extracted strings of length {length} : \",final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141a1ad5",
   "metadata": {},
   "source": [
    "### 11.\tWrite a Python program to remove None values from a given list using the lambda function.\n",
    "list : [12, 0, None, 23, None, -55, 234, 89, None, 0, 6, -12], output : [12, 0, 23, -55, 234, 89, 0, 6, -12]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218b6fe1",
   "metadata": {},
   "source": [
    "#### Ans 11) Steps:\n",
    "- Take a list of elements containing none values.\n",
    "- Write a lambda function that checks whether an element is none or not.\n",
    "- In expression check whether given list is equals to sorted list or not.\n",
    "- Create an object of this function.\n",
    "- Iterate through the list of element and call the function, if function returns True that means value is none and remove it.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "29e40293",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function removes the none values from the list: \n",
      "Input list :  [12, 0, None, 23, None, -55, 234, 89, None, 0, 6, -12]\n",
      "List after removing None values :  [12, 0, 23, -55, 234, 89, 0, 6, -12]\n"
     ]
    }
   ],
   "source": [
    "print(\"This function removes the none values from the list: \")\n",
    "lis11 = [12, 0, None, 23, None, -55, 234, 89, None, 0, 6, -12] \n",
    "print(\"Input list : \",lis11 ,)\n",
    "\n",
    "## creating lambda function\n",
    "fun11 = lambda x : x == None\n",
    "\n",
    "## iterating through each element and calling the lambda function, removing element if it is None.\n",
    "for ele in lis11:\n",
    "    if fun11(ele):\n",
    "        lis11.remove(ele)\n",
    "\n",
    "## printing the final output\n",
    "print(\"List after removing None values : \",lis11)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14c2e9e7",
   "metadata": {},
   "source": [
    "### 12.\tWrite a Python program to count the even and odd numbers in a given array of integers using Lambda.\n",
    "list : [1, 2, 3, 5, 7, 8, 9, 10] , \n",
    "Count of even numbers : 3 , \n",
    "Count of odd numbers : 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f555ffc",
   "metadata": {},
   "source": [
    "#### Ans 12) Steps:\n",
    "- Take a list.\n",
    "- Initialise the even and odd count variables to store the count.\n",
    "- Create a lambda function that check weather a number is even or odd.\n",
    "- Create an object of this function.\n",
    "- Iterate through the list of elements, call the function and update the variable count.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e82d6feb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List : [1, 2, 3, 5, 7, 8, 9, 10]\n",
      "count of even and odd numbers : 3 , 5\n"
     ]
    }
   ],
   "source": [
    "## taking list\n",
    "lis12 = [1, 2, 3, 5, 7, 8, 9, 10] \n",
    "print(\"Given List :\", lis12)\n",
    "\n",
    "## initializing even and odd count variable by zero\n",
    "even_count, odd_count = 0 , 0\n",
    "\n",
    "## creating a lambda function \n",
    "func12 = lambda num : 'even' if num%2==0 else 'odd'\n",
    "\n",
    "## iterating through each number of list and calling the lambda function,, updating the count accordingly.\n",
    "for num in lis12:\n",
    "    if func12(num) == 'even':\n",
    "        even_count += 1\n",
    "    else:\n",
    "        odd_count += 1\n",
    "    \n",
    "## dispaly the final results\n",
    "print(f\"count of even and odd numbers : {even_count} , {odd_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8af8e4a",
   "metadata": {},
   "source": [
    "### 13.\tWrite a Python program to find a list with maximum length using lambda.\n",
    "list : [[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]] , output : (3, [13, 15, 17])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77dbff9",
   "metadata": {},
   "source": [
    "#### Ans 13) Steps:\n",
    "- Take a list.\n",
    "- Initialise the index and max length variables with 0 and first list length respectively.\n",
    "- Create a lambda function that checks weather length of given list if greater than max length or not\n",
    "- Create an object of this function.\n",
    "- Iterate through each element of the list and call the lambda function and update the value of index and max_len.\n",
    "- Print the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6a85aa2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list :  [[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]]\n",
      "output :  (3, [13, 15, 17])\n"
     ]
    }
   ],
   "source": [
    "## list\n",
    "lis13 = [[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]]\n",
    "print(\"Given list : \", lis13)\n",
    "## initialise index and max length variable with 0 and first list length respectively\n",
    "index = 0\n",
    "max_len = len(lis13[0])\n",
    "\n",
    "## create a lambda function that checks weather length of given list if greater than max length or not\n",
    "func13 = lambda lis : len(lis) > max_len\n",
    "\n",
    "\n",
    "## iterate through each element of the list and call the lambda function and update the value of index and max_len\n",
    "for i in range(len(lis13)):\n",
    "    if func13(lis13[i]):\n",
    "        max_len = len(lis13[i])\n",
    "        index = i\n",
    "\n",
    "## display the final result\n",
    "print(\"output : \",(max_len, lis13[index]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74ea1985",
   "metadata": {},
   "source": [
    "### 14.\tWrite a  Python program to reverse strings in a given list of string values using lambda.\n",
    "lists : ['Red', 'Green', 'Blue', 'White', 'Black'] , Reverse list : ['deR', 'neerG', 'eulB', 'etihW', 'kcalB']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a239a9",
   "metadata": {},
   "source": [
    "#### Ans 14) Steps:\n",
    "- Take a list of strings\n",
    "- Create an empyt list\n",
    "- create a lambda function to reverse a given string\n",
    "- Iterate through each string of the list and call the function and append the output into empty list.\n",
    "- Display the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "cf837cb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list :  ['Red', 'Green', 'Blue', 'White', 'Black']\n",
      "Output list with reversed string :  ['deR', 'neerG', 'eulB', 'etihW', 'kcalB']\n"
     ]
    }
   ],
   "source": [
    "## Take a list of strings\n",
    "lis14 = ['Red', 'Green', 'Blue', 'White', 'Black']\n",
    "print(\"Given list : \", lis14)\n",
    "\n",
    "## Create an empyt list\n",
    "empty = []\n",
    "\n",
    "## create a lambda function to reverse a given string\n",
    "fun14 = lambda s:s[::-1]\n",
    "\n",
    "## Iterate through each string of the list and call the function and append the output into empty list.\n",
    "for s in lis14:\n",
    "    empty.append(fun14(s))\n",
    "    \n",
    "## Display the result\n",
    "print(\"Output list with reversed string : \" , empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7b1d464",
   "metadata": {},
   "source": [
    "Good questions / important questions : "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d8fc4b",
   "metadata": {},
   "source": [
    "### 15.\tWrite a Python program to sort a list of tuples based on numbers using Lambda.\n",
    "list of tuples : [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)] , \n",
    "Sorted List of Tuples : [('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7cde34",
   "metadata": {},
   "source": [
    "#### Ans 15) \n",
    "1. When we want to sort any collective data in ascending or descending we can simply sort by using sort or sorted method.\n",
    "2. But When we have to sort any collective data based on specific condition then we write that specific condition using lambda function inside the sort method.\n",
    "3. In sort method there is a parameter `key` where we can write the lmabda function.\n",
    "\n",
    "#### Steps:\n",
    "- Take a list of tuple.\n",
    "- Sort the list based on numeric values i.e second element of tuple.\n",
    "- Pass the lambda function to key parameter inside the sort method.\n",
    "- lambda function takes one tuple at a time i.e x , to sort it and we know that in tuple values store from 0th index. And we want to sort the tuple based on its second index i.e 1.\n",
    "- Therefore x : tuple , x[1] : second value.\n",
    "- Finally sort it and display the final result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d4525aee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function sort the list of tuple based on its second element i.e number\n",
      "given list is  :  [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]\n",
      "Final sorted list :  [('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]\n"
     ]
    }
   ],
   "source": [
    "print(\"This function sort the list of tuple based on its second element i.e number\")\n",
    "lis15 = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]\n",
    "print(\"given list is  : \", lis15)\n",
    "\n",
    "\n",
    "## sort the list by using sort method and writing a lambda function to tell the sort method on which value sorted should be happen\n",
    "lis15.sort(key = lambda x : x[1])\n",
    "\n",
    "## display the final sorted list of tuple\n",
    "print(\"Final sorted list : \",lis15)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bce1a3c0",
   "metadata": {},
   "source": [
    "### 16.\tWrite a  Python program to sort a list of dictionaries using Lambda.\n",
    "list of dictionaries : [{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Mi Max', 'model': '2', 'color': 'Gold'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}] , \n",
    "Sorted List of dictionaries based on color :\n",
    "[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': '2', 'color': 'Gold'}]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd910cf5",
   "metadata": {},
   "source": [
    "#### Ans 16)  Steps: \n",
    "- Take a list of dictionaries.\n",
    "- Sort the list of dictionary based on color.\n",
    "- Pass the lambda function to key parameter inside the sort method.\n",
    "- lambda function takes one dictionary at a time i.e x , to sort it. We know that in dictionary values can be accessed using key. And we want to sort the dictionary based on its key color.\n",
    "- Therefore x : dictionary , x['color'] : key.\n",
    "- Finally sort it and display the final result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e92fdb03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of dictionaries after sorting it : \n",
      " [{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': '2', 'color': 'Gold'}]\n"
     ]
    }
   ],
   "source": [
    "## Take a list of dictionaries\n",
    "lis16 = [{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Mi Max', 'model': '2', 'color': 'Gold'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}]\n",
    "\n",
    "## using list sort method pass the lambda function to the key parameter and sort based on color\n",
    "lis16.sort(key = lambda x : x['color'])\n",
    "\n",
    "print(\"List of dictionaries after sorting it : \\n\",lis16)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c7025e",
   "metadata": {},
   "source": [
    "### 17.\tWrite a  Python program to sort each sublist of strings in a given list of lists using lambda.\n",
    "list : [['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']] , \n",
    "Sorted list : [['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1462fd",
   "metadata": {},
   "source": [
    "#### Ans 17)  Steps: \n",
    "- Take a list of lists.\n",
    "- Creating the lambda function to sort the list\n",
    "- Create an empty list to store the lists after sorting them.\n",
    "- Iterating through list of list and calling the function to sort it after that appending it into list.\n",
    "- Display the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "b4b423f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']]\n",
      "Sorted List :  [['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n"
     ]
    }
   ],
   "source": [
    "## given list of list\n",
    "lis17 = [['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']]\n",
    "print(\"Given List : \",lis17)\n",
    "\n",
    "## creating the lambda function to sort the list\n",
    "func17 = lambda x : x.sort()\n",
    "\n",
    "## create an empty list\n",
    "newEmpty = []\n",
    "\n",
    "## iterating through list of list and calling the function to sort it after that appending it into list.\n",
    "for lis in lis17:\n",
    "    func17(lis)\n",
    "    newEmpty.append(lis)\n",
    "\n",
    "## Display the output\n",
    "print(\"Sorted List : \",newEmpty)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc04deec",
   "metadata": {},
   "source": [
    "### 18.\tWrite a Python program to sort a given matrix in ascending order according to the sum of its rows using lambda.\n",
    "Matrix : [[1, 2, 3], [2, 4, 5], [1, 1, 1]] , \n",
    "Sorted matrix : [[1, 1, 1], [1, 2, 3], [2, 4, 5]]\n",
    "Matrix : [[1, 2, 3], [-2, 4, -5], [1, -1, 1]] , \n",
    "Sorted matrix : [[-2, 4, -5], [1, -1, 1], [1, 2, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c82988",
   "metadata": {},
   "source": [
    "#### Ans 18)  Steps: \n",
    "- Take a matrix\n",
    "- Create a lambda function to sort the list based on list sum\n",
    "- Call the lambda function.\n",
    "- Display the final sorted matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "fdf1257c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input list :  [[1, 2, 3], [2, 4, 5], [1, 1, 1]]\n",
      "Output :  [[1, 1, 1], [1, 2, 3], [2, 4, 5]]\n"
     ]
    }
   ],
   "source": [
    "## take a matrix\n",
    "lis18 = [[1, 2, 3], [2, 4, 5], [1, 1, 1]]\n",
    "print(\"Input list : \", lis18)\n",
    "\n",
    "## create a lambda function to sort the list based on list sum\n",
    "func18 = lambda x : x.sort(key= sum)\n",
    "\n",
    "## call the lambda function\n",
    "func18(lis18)\n",
    "\n",
    "## display the final sorted matrix\n",
    "print(\"Output : \",lis18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12fa4cc5",
   "metadata": {},
   "source": [
    "### 19.\tWrite a  Python program to sort a list of lists by a given index of the inner list using lambda.\n",
    "list : [('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] , \n",
    "Sort the list by a given index ( Index = 0 ) of the inner tuple : \n",
    "[('Beau Turnbull', 94, 98), ('Brady Kent', 97, 96), ('Greyson Fulton', 98, 99), ('Wyatt Knott', 91, 94)] , \n",
    "Sort the list by a given index ( Index = 2 ) of the inner tuple : \n",
    "[('Wyatt Knott', 91, 94), ('Brady Kent', 97, 96), ('Beau Turnbull', 94, 98), ('Greyson Fulton', 98, 99)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e138b29",
   "metadata": {},
   "source": [
    "#### Ans 19)  Steps: \n",
    "- Take a list of tuples\n",
    "- Taking index from user\n",
    "- Creating a lambda function inside sort method to sort the list based on index\n",
    "- Call the lambda function.\n",
    "- Display the sorted list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "3d5c9b80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list :  [('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)]\n",
      "Enter the index between 0-2 to sort the above list based on index : 1\n",
      "Sorted list :  [('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98), ('Brady Kent', 97, 96), ('Greyson Fulton', 98, 99)]\n"
     ]
    }
   ],
   "source": [
    "## given list of tuples\n",
    "lis19 = [('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)]\n",
    "print(\"Given list : \",lis19)\n",
    "\n",
    "## taking index from user\n",
    "index = int(input(\"Enter the index between 0-2 to sort the above list based on index : \"))\n",
    "\n",
    "## Creating a lambda function to sort the list based on index\n",
    "lis19.sort(key= lambda x : x[index])\n",
    "\n",
    "## display the sorted list\n",
    "print(\"Sorted list : \", lis19)"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}