Python_assignment_17th_Sept .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "347d21ce-af46-4081-9c62-011b160e9aad",
   "metadata": {},
   "source": [
    "# For Loop :-\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c61677f-6d16-4ab7-a896-28fa9fd33619",
   "metadata": {},
   "source": [
    "### 1.Write a Python program to print numbers from 1 to 10 using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f982a433-ab44-4be4-8364-66a59606b82d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "i=10 # assign the value.\n",
    "for i in range(i): # Using for loop iterate i+1.\n",
    "    print(i+1) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8eda9ba-f8d5-45ba-838e-10ef21f0a213",
   "metadata": {},
   "source": [
    "### 2.Explain the difference between a for loop and a while loop in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a6fdd609-eefd-4dd3-95d6-d602502c6514",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is for loop\n"
     ]
    }
   ],
   "source": [
    "a=[1] # take a value.\n",
    "for i in a: # iterate i value.\n",
    "    print(\"This is for loop\") # print the result one time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f74f10c5-6512-41e4-bc5a-f4ce33088138",
   "metadata": {},
   "outputs": [],
   "source": [
    "while True: # while condition is true.\n",
    "    print(\"This is while loop\") # print the result until condition becomes false."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc173666-1956-4e2c-93b6-cdfab7e6694a",
   "metadata": {},
   "source": [
    "### 3.Write a Python program to calculate the sum of all numbers from 1 to 100 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7fb08534-9571-4257-a7f5-e6f2949cd62e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n"
     ]
    }
   ],
   "source": [
    "n=100  # take a value.\n",
    "sum=0   # sum=0.\n",
    "for i in range(n+1):  # Iterate n value as n+1.\n",
    "    sum+=i # concate the sum and i value.\n",
    "print(sum) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f36dbcc-3620-490a-a292-2b3481229c8e",
   "metadata": {},
   "source": [
    "### 4.How do you iterate through a list using a for loop in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "772797d2-dcb8-450d-b09b-204c96a6b744",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "l=[1,2,3,4,5,6] # Take a list.\n",
    "for i in l: # iterate l as i.\n",
    "    print(i) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a97cf34c-2fb6-41fa-9804-17ccacb281ea",
   "metadata": {},
   "source": [
    "### 5.Write a Python program to find the product of all elements in a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cae5dfe2-fc0b-4095-a99a-43bf7eeee41e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "l1=[1,2,3,4,5] # Take a l1 of list. \n",
    "for i in l1: # Iterate a list elements. \n",
    "    print(i*i) # print the product of all elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5b8a413-b788-4e63-86e5-f427f950b92a",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that prints all even numbers from 1 to 20 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d9ef1a84-0b30-4dc3-a6ca-23185cf1d0af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "for x in range(1,21): # Iterate x in range of 1 to 20.\n",
    "    if x%2==0: # if condition is true that means even.\n",
    "        print(x) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51c951d-8e2f-404f-9bae-1fc6596cf3a2",
   "metadata": {},
   "source": [
    "### 7.Write a Python program that calculates the factorial of a number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9ebb06b2-4016-4cfe-b15a-b711811fe029",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "n=int(input()) # Take a input from the user.\n",
    "fact=1 \n",
    "for i in range(1,n+1):  # iterate i value \n",
    "    if n>=1:   # condition if  n is lessthan or equal to 1. \n",
    "        fact=fact*i   \n",
    "print(fact) # praint the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e858929-b25f-4603-af72-7d20d2bb9057",
   "metadata": {},
   "source": [
    "### 8.How can you iterate through the characters of a string using a for loop in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "350bbd6d-706d-40c0-ba1a-ff4c17c7e824",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rama\n",
      "krishna\n",
      "datascience\n",
      "pwskills\n"
     ]
    }
   ],
   "source": [
    "str='rama','krishna','datascience','pwskills' # Take a character.\n",
    "for i in str: # Iterate string as i.\n",
    "    print(i) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19332f87-07b5-4d0f-9527-18252634fe22",
   "metadata": {},
   "source": [
    "### 9.Write a Python program to find the largest number in a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1a4eef3b-d8cf-46e8-bba8-db6693a859b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of elements in list:  4\n",
      "Enter elements:  11\n",
      "Enter elements:  1499\n",
      "Enter elements:  52\n",
      "Enter elements:  2000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Largest element is: 2000\n"
     ]
    }
   ],
   "source": [
    "# Creating an empty list\n",
    "list1 = []\n",
    "# asking number of elements to put in list\n",
    "num = int(input(\"Enter number of elements in list: \"))\n",
    "# Iterating till num to append elements in list\n",
    "for i in range(1, num + 1):\n",
    "\tele = int(input(\"Enter elements: \"))\n",
    "\tlist1.append(ele)\n",
    "# Printing maximum element\n",
    "print(\"Largest element is:\", max(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75583b02-5f1e-49b9-a918-c2264c0f93ac",
   "metadata": {},
   "source": [
    "### 10.Create a Python program that prints the Fibonacci sequence up to a specified limit using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6354ca5d-5657-465f-99bb-2d9e2a24f8c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 "
     ]
    }
   ],
   "source": [
    "# Fibonacci Series in Python Using For Loop\n",
    "# initialize two variables, with value 0\n",
    "a, b = 0, 1\n",
    "series_length = 10\n",
    "print(a, b, end=' ')\n",
    "for i in range(series_length):\n",
    "    c = a + b\n",
    "    print(c, end=' ')\n",
    "    a = b\n",
    "    b = c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abc90e78-2ecd-4af8-a71c-64d179100ea0",
   "metadata": {},
   "source": [
    "### 11.Write a Python program to count the number of vowels in a given string using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bd54e128-14f6-472a-a7d0-a0cc21578c69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "count=0 # initilize count is 0.\n",
    "v='ramakrishna' # take v value.\n",
    "for i in v: # Iterate v elements.\n",
    "    if i=='a'or i=='e' or i=='i' or i=='o' or i=='u':\n",
    "        count=count+1\n",
    "        print(count) # print the reslut."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8500dd8-d9bd-43e6-8df7-9df5146618d7",
   "metadata": {},
   "source": [
    "### 12.Create a Python program that generates a multiplication table for a given number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a324501d-acc7-4438-ad58-ad3f9e60683c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 x 1 = 5\n",
      "5 x 2 = 10\n",
      "5 x 3 = 15\n",
      "5 x 4 = 20\n",
      "5 x 5 = 25\n",
      "5 x 6 = 30\n",
      "5 x 7 = 35\n",
      "5 x 8 = 40\n",
      "5 x 9 = 45\n",
      "5 x 10 = 50\n"
     ]
    }
   ],
   "source": [
    "a=5 # initilize the value.\n",
    "for i in range(1,11): # iterate i in range as 1 to 10.\n",
    "    print(a,'x', i,'=',a*i) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49d6281-96cb-4dd4-800b-98dd368579d5",
   "metadata": {},
   "source": [
    "### 13.Write a Python program to reverse a list using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e869a057-59fb-4f48-b29f-e704cbb97dac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anhsirkamar\n"
     ]
    }
   ],
   "source": [
    "a=['ramakrishna'] # take a list.\n",
    "for i in a: # iterate a list . \n",
    "    print(i[::-1]) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "210c8faf-5da4-49cb-acdb-157305fddd0f",
   "metadata": {},
   "source": [
    "### 14.Write a Python program to find the common elements between two lists using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4616437b-6acf-417b-b785-af43d9954cf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The common elements in the two lists are: \n",
      "[3]\n"
     ]
    }
   ],
   "source": [
    "def common_member(a, b): # define function.\n",
    "    result = [i for i in a if i in b] # result is if list-1 in list-2 .\n",
    "    return result # return.\n",
    "a = [1, 2, 3, 4, 5] \n",
    "b = [3, 6, 7, 8, 9]  # initilize two lists.\n",
    "print(\"The common elements in the two lists are: \")\n",
    "print(common_member(a, b))        # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbc8b9d0-8a05-40ae-836f-12d302b290d0",
   "metadata": {},
   "source": [
    "### 15.Explain how to use a for loop to iterate through the keys and values of a dictionary in Python.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5253515b-8eb8-4131-b819-777bef8c09c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'ramakrishna', 'phnno': 9333336665, 'subject': 'datascience'}\n",
      "{'name': 'ramakrishna', 'phnno': 9333336665, 'subject': 'datascience'}\n",
      "{'name': 'ramakrishna', 'phnno': 9333336665, 'subject': 'datascience'}\n"
     ]
    }
   ],
   "source": [
    "d={\"name\":\"ramakrishna\",\"phnno\":9333336665,\"subject\":\"datascience\"} # initilize the dictionary.\n",
    "for i in d: # iterate the keys and values using for loop.\n",
    "    print(d) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73696360-fc79-46d0-9156-5c087ed4dbcf",
   "metadata": {},
   "source": [
    "### 16.Write a Python program to find the GCD (Greatest Common Divisor) of two numbers using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "36ec742a-f755-4483-9438-2ca0d64b0b6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of 65 and 60 is 5\n"
     ]
    }
   ],
   "source": [
    "num1 = 65\n",
    "num2 = 60 # initilize the two elements.\n",
    "gcd = 1\n",
    "for i in range(1, min(num1, num2)): # iterate the two values.\n",
    "    if num1 % i == 0 and num2 % i == 0: # if condition will satisfy.\n",
    "        gcd = i\n",
    "print(\"GCD of\", num1, \"and\", num2, \"is\", gcd) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58ee581-2c08-407f-aed8-bb011e420f4d",
   "metadata": {},
   "source": [
    "### 17.Create a Python program that checks if a string is a palindrome using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8c0c00e6-6523-4678-99f3-25eafca6b917",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "palindrome\n",
      "palindrome\n",
      "palindrome\n",
      "palindrome\n",
      "palindrome\n"
     ]
    }
   ],
   "source": [
    "p=\"racer\" # initilize the value.\n",
    "for i in p: # iterate the value \n",
    "    if i==i[::-1]: # if condition is true.\n",
    "        print(\"palindrome\") # print the result.\n",
    "    else:\n",
    "        print(\"not a palindrome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77e54119-d753-481e-b74a-eb5cd1352bd9",
   "metadata": {},
   "source": [
    "### 18.Write a Python program to remove duplicates from a list using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6489b96e-f1a9-4c98-9c83-68814c1af0ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list is : [1, 3, 5, 6, 3, 5, 6, 1]\n",
      "The list after removing duplicates : [1, 3, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "                                              # initializing list\n",
    "test_list = [1, 3, 5, 6, 3, 5, 6, 1]\n",
    "print(\"The original list is : \"+ str(test_list))\n",
    "                                               # using list comprehension to remove duplicated from list\n",
    "res = []\n",
    "[res.append(x) for x in test_list if x not in res]\n",
    "\n",
    "                                               # printing list after removal\n",
    "print (\"The list after removing duplicates : \"+ str(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68cf3a4a-c4d3-488b-8f5f-8417bb7cfa6c",
   "metadata": {},
   "source": [
    "### 19.Create a Python program that counts the number of words in a sentence using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "91a0ea10-41fd-4112-9daf-e3565edfe233",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "the words are in a sentence is: krishna\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "7\n",
      "7\n",
      "7\n",
      "7\n",
      "7\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "g=input(\"the words are in a sentence is:\")  # take input from the user.\n",
    "for i in g: # iterate the value.\n",
    "    print(len(g)) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f82dde14-ebc1-40b1-8f3b-8f55b633fe86",
   "metadata": {},
   "source": [
    "### 20.Write a Python program to find the sum of all odd numbers from 1 to 50 using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a5ecd607-d95d-42bd-89f6-70bd36da6659",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "6\n",
      "10\n",
      "14\n",
      "18\n",
      "22\n",
      "26\n",
      "30\n",
      "34\n",
      "38\n",
      "42\n",
      "46\n",
      "50\n",
      "54\n",
      "58\n",
      "62\n",
      "66\n",
      "70\n",
      "74\n",
      "78\n",
      "82\n",
      "86\n",
      "90\n",
      "94\n",
      "98\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,51): # iterate a values from 1 to 50.\n",
    "    if i%2!=0: # condition is true.\n",
    "        i=i+i\n",
    "        print(i) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99a4381-9055-4ab3-af2b-ee167eb303e8",
   "metadata": {},
   "source": [
    "### 21.Write a Python program that checks if a given year is a leap year using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1248e27a-c446-4a7e-b553-6d1d1d512d18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter the year you would like to start checking leap years from. 1990\n",
      "Please enter over how many years you would like to check. 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1990 this is not a leap year\n",
      "1991 this is not a leap year\n",
      "1992 this is not a leap year\n",
      "1993 this is not a leap year\n",
      "1994 this is not a leap year\n"
     ]
    }
   ],
   "source": [
    "year = int(input(\"Please enter the year you would like to start checking leap years from.\"))\n",
    "total_years = int(input(\"Please enter over how many years you would like to check.\"))\n",
    "leap_year= 0\n",
    "\n",
    "if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):   \n",
    "    leap_year = (\"this is a leap year\")\n",
    "\n",
    "else:\n",
    "    leap_year = (\"this is not a leap year\")\n",
    "for a in range (0,total_years):\n",
    "    print(year + a, leap_year)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "627fa3a8-cb1c-495e-ac2d-a3a342bb9815",
   "metadata": {},
   "source": [
    "### 22.Create a Python program that calculates the square root of a number using a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "af60a88c-7086-42e8-bc60-5738ebaabe1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4641016151377544\n"
     ]
    }
   ],
   "source": [
    "import math # Import a math function.\n",
    "a=[12] # initilize the number. \n",
    "for i in a: # iterate the number as i.\n",
    "    m=math.sqrt(i) # apply square root for given number.\n",
    "    print(m) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab281c7d-a458-48e7-b0b3-e33c8c708238",
   "metadata": {},
   "source": [
    "### 23.Write a Python program to find the LCM (Least Common Multiple) of two numbers using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "da1346dd-ac12-4127-9078-4ba21be90f43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LCM of 12 and 14 is 84\n"
     ]
    }
   ],
   "source": [
    "num1 = 12 # initilize the two numbers.\n",
    "num2 = 14 \n",
    "for i in range(max(num1, num2), 1 + (num1 * num2)): # iterate the number.\n",
    "    if i % num1 == i % num2 == 0: # condition is satisy .\n",
    "        lcm = i # assign number as lcm.\n",
    "        break # then the the process.\n",
    "print(\"LCM of\", num1, \"and\", num2, \"is\", lcm)# print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6d660f-96e0-49fb-82b3-ff235a288a68",
   "metadata": {},
   "source": [
    "# If else :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdce18de-c824-4d4e-9587-3be3fe4bb0a6",
   "metadata": {},
   "source": [
    "### 1.Write a Python program to check if a number is positive, negative, or zero using an if-else statement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "185e6601-70b0-4607-a171-921f7ae5cc09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a number 88\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "positive number\n"
     ]
    }
   ],
   "source": [
    "a=int(input(\"enter a number\")) # take input from the user.\n",
    "if a<0:                        # condition for negative number. \n",
    "    print(\"negative number\")\n",
    "if a>0:\n",
    "    print(\"positive number\")\n",
    "else:\n",
    "    print(\"zero\") # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc6e9217-c52e-4cdf-812f-c97b511fbadb",
   "metadata": {},
   "source": [
    "### 2.Create a Python program that checks if a given number is even or odd using an if-else statement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0afb5163-93e9-4d1b-b72a-d41bc3d96b9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even number\n"
     ]
    }
   ],
   "source": [
    "b=56                       # take value.\n",
    "if b%2==0:\n",
    "    print(\"even number\") # print the result if condition is true.\n",
    "else:\n",
    "    print(\"odd number\") # print else condition is true."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70559a2e-906a-4366-972b-c8805521dfaf",
   "metadata": {},
   "source": [
    "### 3.How can you use nested if-else statements in Python, and provide an example?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "398862ef-1cae-4f0c-b51e-de83ba069b43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a number 58\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "positive number\n"
     ]
    }
   ],
   "source": [
    "a=int(input(\"enter a number\")) # take input from the user.\n",
    "if a<0:                        # condition for negative number. \n",
    "    print(\"negative number\")\n",
    "if a>0:\n",
    "    print(\"positive number\")\n",
    "else:\n",
    "    print(\"zero\") # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "797b9d67-8ec3-4164-94ef-e51908c39574",
   "metadata": {},
   "source": [
    "### 4.Write a Python program to determine the largest of three numbers using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3e298d0f-41a0-46ac-858e-729bb04d5b90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the largest number is 966\n"
     ]
    }
   ],
   "source": [
    "num1=12\n",
    "num2=78\n",
    "num3=966                                      # Assign the numbers.\n",
    "if num1>num2 and num1>num3:                   \n",
    "    print(\"the largest number is\",num1)       # print if condition is true.\n",
    "if num2>num1 and num2>num3:\n",
    "    print(\"the largest number is\",num2)       # print if condition is true.\n",
    "else:\n",
    "    print(\"the largest number is\",num3)       # print else condition is true."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9124cef-0d85-4038-b3de-84ad6d76e32b",
   "metadata": {},
   "source": [
    "### 5.Write a Python program that calculates the absolute value of a number using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "626ba6db-6386-41ca-9ef9-6eb66c8c108c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Absolute value of 5 =  5\n",
      "Absolute value of -5 =  5\n"
     ]
    }
   ],
   "source": [
    "def getAbsoluteValue(value):\n",
    "   # checking whether the number is less than 0\n",
    "   if(value<0):\n",
    "      # returning negative of the value if the condition is true\n",
    "      # i.e -(-) value becomes plus(+)\n",
    "      return -value\n",
    "   # returning the number passed\n",
    "   return value\n",
    "# calling the getAbsoluteValue() function by passing some random positive number\n",
    "print(\"Absolute value of 5 = \", getAbsoluteValue(5))\n",
    "# calling the getAbsoluteValue() function by passing some random negative number\n",
    "print(\"Absolute value of -5 = \", getAbsoluteValue(-5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ccb86c5-ad3a-45ae-a325-4b929f0debe1",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that checks if a given character is a vowel or consonant using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3d6f6410-8e6f-4c02-9c0d-597c0cd6da6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "consonant\n"
     ]
    }
   ],
   "source": [
    "a=\"pwskills\"       # initilize the value.\n",
    "if a=='a'or a=='e'or a=='i'or a=='o'or a=='u'or a=='A'or a=='E'or a=='I'or a=='O'or a=='U':\n",
    "    print(\"vowel\") # print if it is a vowel. \n",
    "else:\n",
    "    print(\"consonant\") # print if it is consonant."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6855854-dd88-41a2-8aea-a0ccf114f225",
   "metadata": {},
   "source": [
    "### 7.Write a Python program to determine if a user is eligible to vote based on their age using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0963dc1a-28b7-4f9b-99e4-7312c37f91ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 18\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "your eligible for vote\n"
     ]
    }
   ],
   "source": [
    "age=int(input())                          # Take age from the user.\n",
    "if age>=18:\n",
    "    print(\"your eligible for vote\") # print the result if age is under 18.\n",
    "else:\n",
    "    print(\"your not eligible for vote\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7021f0a0-1022-4be0-9459-1cdf43cefadd",
   "metadata": {},
   "source": [
    "### 8.Create a Python program that calculates the discount amount based on the purchase amount using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "689766e4-0ad2-4829-9199-38bed580e63f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter Sale Amount:  5000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discount :  250.0\n",
      "Net Pay  :  4750.0\n"
     ]
    }
   ],
   "source": [
    "                                       # input sale amount\n",
    "amt = int(input(\"Enter Sale Amount: \"))\n",
    "                                      # checking conditions and calculating discount\n",
    "if(amt>0):\n",
    "    if amt<=5000:\n",
    "        disc = amt*0.05\n",
    "    elif amt<=15000:\n",
    "        disc=amt*0.12\n",
    "    elif amt<=25000:\n",
    "        disc=0.2 * amt\n",
    "    else:\n",
    "         disc=0.3 * amt\n",
    "\n",
    "    print(\"Discount : \",disc)\n",
    "    print(\"Net Pay  : \",amt-disc)\n",
    "else:\n",
    "    print(\"Invalid Amount\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763cd199-8adf-40f1-aa60-5dd35df6e3ca",
   "metadata": {},
   "source": [
    "### 9.Write a Python program to check if a number is within a specified range using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b01b68a3-9f45-4a30-a215-0057767b4b51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number :  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55 is not present in the range.\n"
     ]
    }
   ],
   "source": [
    "range_1 = range(2, 20, 3)              # Take a range.\n",
    "number = int(input('Enter a number : ')) # take input from the user.\n",
    " \n",
    "if number in range_1 :\n",
    "    print(number, 'is present in the range.')\n",
    "else :\n",
    "    print(number, 'is not present in the range.') # print the  result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be7565a8-618c-44b9-961f-46c4829e202d",
   "metadata": {},
   "source": [
    "### 10.Create a Python program that determines the grade of a student based on their score using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c6bd4ed8-a3c3-4040-8c4b-58321896b336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter your marks 50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C grade\n"
     ]
    }
   ],
   "source": [
    "score=int(input('enter your marks')) # take inputfrom the user.\n",
    "if score>=80:\n",
    "    print(\"A grade\")              # print first condition will satisfy.\n",
    "if score>=60 and score<=79:\n",
    "    print(\"B grade\")              \n",
    "if score<=50 and score<=59:     \n",
    "    print(\"C grade\")              # print score between 50 to 59.\n",
    "else:\n",
    "    print(\"D grade\")              # print else condition will satisy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "861ba6a0-25b0-42d7-ae85-5e1c364cd8bf",
   "metadata": {},
   "source": [
    "### 11.Write a Python program to check if a string is empty or not using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e84205b8-051a-4c0b-88a4-eb8f585208e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a empty string\n"
     ]
    }
   ],
   "source": [
    "s=\"\"                                   # take a empty string.\n",
    "len(s)                                 # find the length of a string.\n",
    "if len(s)==0:\n",
    "    print(\"this is a empty string\")     \n",
    "else:                                   # print the result.\n",
    "    print(\"this is not a empty string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "688724ee-f1b2-494a-9209-fa4a0dbf1a53",
   "metadata": {},
   "source": [
    "### 12. Create a Python program that identifies the type of a triangle (e.g., equilateral, isosceles, or scalene) based on input values using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e12e96c2-2fb9-4e43-938f-3176aeba3e6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a value 12\n",
      "enter b value 12\n",
      "enter c value 13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isosceles triangle\n"
     ]
    }
   ],
   "source": [
    "a=int(input(\"enter a value\"))\n",
    "b=int(input(\"enter b value\"))\n",
    "c=int(input(\"enter c value\"))            # input from the user.\n",
    "if a==b==c:\n",
    "    print(\"equilateral traingle\")\n",
    "elif a==b or a==c:\n",
    "    print(\"isosceles triangle\")          # print if it isosceles\n",
    "elif a!=b!=c:\n",
    "    print(\"scalene triangle\")            # print if it is scalene.\n",
    "else:\n",
    "    print(\"invalid\")                   # print the if it invalid."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bc2be69-2b27-440d-ba4c-5da5f35ab88a",
   "metadata": {},
   "source": [
    "### 13. Write a Python program to determine the day of the week based on a user-provided number using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "af4df25d-c4e9-44f9-b05f-01470323d113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter day in a week in 1 to 7 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thursday\n"
     ]
    }
   ],
   "source": [
    "day=int(input(\"enter day in a week in 1 to 7\"))  # take a input from the user.\n",
    "if day==1:                   \n",
    "    print(\"sunday\")                  # if it is 1 then print sunday.\n",
    "elif day==2:\n",
    "    print(\"monday\")\n",
    "elif day==3:\n",
    "    print(\"tuesday\")\n",
    "elif day==4:\n",
    "    print(\"wednesday\")\n",
    "elif day==5:                          # if it is 5 then print thursday.\n",
    "    print(\"thursday\")\n",
    "elif day==6:\n",
    "    print(\"friday\")                            \n",
    "elif day==7:\n",
    "    print(\"saturday\")                # if it is 7 then print saturday.\n",
    "else:\n",
    "    print(\"invalid\")                 # invalid input "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75042884-5a63-464c-a4ee-308a8abe4d63",
   "metadata": {},
   "source": [
    "### 14.Create a Python program that checks if a given year is a leap year using both if-else and a function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4bf4a6fb-1cb1-4668-8ae7-022e0a3a3116",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  2004\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004 is leap year\n"
     ]
    }
   ],
   "source": [
    "def check_leap(year):                                               # define a function.\n",
    "    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0) # condition for a leap year.\n",
    "year = int(input(\"Enter a year: \")) \n",
    "print(f\"{year} is leap year\" if check_leap(year) else f\"{year} is not leap year\") # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7b7fcc9-39d8-4e90-9cb8-9f7791a97a1f",
   "metadata": {},
   "source": [
    "### 15.How do you use the \"assert\" statement in Python to add debugging checks within if-else blocks?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5fdf9f1-2697-400b-a616-5e3a4108ceb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Denominator cannot be zero\n"
     ]
    }
   ],
   "source": [
    "def divide_numbers(a, b):\n",
    "    assert b != 0,      # \"Division by zero is not allowed\"\n",
    "    result = a / b\n",
    "    return result\n",
    "\n",
    "numerator = 10\n",
    "denominator = 0\n",
    "\n",
    "if denominator != 0:\n",
    "    quotient = divide_numbers(numerator, denominator)\n",
    "    print(\"Quotient is:\", quotient)\n",
    "else:\n",
    "    print(\"Denominator cannot be zero\")   # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b29077a4-35b0-453d-9daa-92a9ef0c24b6",
   "metadata": {},
   "source": [
    "### 16.Create a Python program that determines the eligibility of a person for a senior citizen discount based on age using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "17265174-8b76-4562-9e07-f5beb0d67872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a person eligible for discount\n"
     ]
    }
   ],
   "source": [
    "age=60  # take a age.\n",
    "if age>=60: # if age is greather than 60.\n",
    "    print(\"a person eligible for discount\") # print the result.\n",
    "else:\n",
    "    print(\"a person is not eligible for discount\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c5db675-f8b2-42a4-af26-b43f1fc644d1",
   "metadata": {},
   "source": [
    "### 17.Write a Python program to categorize a given character as uppercase, lowercase, or neither using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "87a43d37-c222-4142-b8af-d9b04904c2aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a lowercase characters\n"
     ]
    }
   ],
   "source": [
    "ch=\"rAmaKRIshnA\"  # take a value.\n",
    "if ch>\"A\" and ch<\"Z\":        # if ch is greatherthan A and lowerthan Z.\n",
    "    print(\"this is uppercase characters\")  # print the result.\n",
    "elif ch>\"a\" and ch<\"z\":\n",
    "    print(\"this is a lowercase characters\")\n",
    "else:\n",
    "    print(\"neither\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b796a711-520d-4a7b-8827-2400cc50b86e",
   "metadata": {},
   "source": [
    "### 18.Write a Python program to determine the roots of a quadratic equation using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a2dcfa52-2759-4fcb-99e5-81c8edf0264d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter coefficient a:  1\n",
      "Enter coefficient b:  5\n",
      "Enter coefficient c:  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The roots are real and distinct.\n",
      "Root 1: -2.0\n",
      "Root 2: -3.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "                                                   # Get coefficients from the user\n",
    "a = float(input(\"Enter coefficient a: \"))\n",
    "b = float(input(\"Enter coefficient b: \"))\n",
    "c = float(input(\"Enter coefficient c: \"))\n",
    "                                                    # Calculate the discriminant\n",
    "discriminant = b**2 - 4*a*c\n",
    "                                                    # Determine the roots based on the discriminant\n",
    "if discriminant > 0:\n",
    "    root1 = (-b + math.sqrt(discriminant)) / (2*a)\n",
    "    root2 = (-b - math.sqrt(discriminant)) / (2*a)\n",
    "    print(\"The roots are real and distinct.\")\n",
    "    print(\"Root 1:\", root1)\n",
    "    print(\"Root 2:\", root2)\n",
    "elif discriminant == 0:\n",
    "    root = -b / (2*a)\n",
    "    print(\"The roots are real and equal.\")\n",
    "    print(\"Root:\", root)\n",
    "else:\n",
    "    realPart = -b / (2*a)\n",
    "    imaginaryPart = math.sqrt(abs(discriminant)) / (2*a)\n",
    "    print(\"The roots are complex and imaginary.\")\n",
    "    print(\"Root 1:\", realPart, \"+\", imaginaryPart, \"i\")\n",
    "    print(\"Root 2:\", realPart, \"-\", imaginaryPart, \"i\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99c49e29-b8ad-4e0d-ad14-10cd3147d617",
   "metadata": {},
   "source": [
    "### 19.Create a Python program that checks if a given year is a century year or not using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8b73db9c-d284-482b-bedb-5940c11c0607",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a year 1233\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1233 is not a century year\n"
     ]
    }
   ],
   "source": [
    "year=int(input(\"enter a year\")) # take a input from the user.\n",
    "if year%100==0:                 # if year is divided by 100 equal to 0.\n",
    "    print(f\"{year} is century year\") # print the result.\n",
    "else:\n",
    "    print(f\"{year} is not a century year\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1376c931-eed5-4a0c-a684-570d026b397e",
   "metadata": {},
   "source": [
    "### 20.Write a Python program to determine if a given number is a perfect square using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a8405886-b5a5-4870-8b23-79d5357a8621",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is a perfect square\n"
     ]
    }
   ],
   "source": [
    "import math      # import math.\n",
    "num = 25         # number =25.\n",
    "sqrt_num = math.sqrt(num)  \n",
    "if sqrt_num.is_integer():   #if condition is true print the result.\n",
    "    print(\"The number is a perfect square\")  \n",
    "else:  \n",
    "    print(\"The number is not a perfect square\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "635a5f29-1285-4ea0-a8ba-ac3e04931231",
   "metadata": {},
   "source": [
    "### 21.Explain the purpose of the \"continue\" and \"break\" statements within if-else loops.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c2b7a700-0f89-4230-ab68-e58fc86f77cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    if i == 3:\n",
    "        continue # it will skip the next iteration.\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6a5a44b6-f26b-4338-aa36-d34f5a52d039",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    if i == 4:\n",
    "        break # it will stop  the iteration.\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0d639f4-f646-4ecd-9ef0-a41aa142d608",
   "metadata": {},
   "source": [
    "### 22.Create a Python program that calculates the BMI (Body Mass Index) of a person based on their weight and height using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "74694164-fa3d-40ed-b658-a81a22c87dba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your weight in kilograms:  60\n",
      "Enter your height in meters:  5.8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your BMI is: 1.78\n",
      "You are categorized as: Underweight\n"
     ]
    }
   ],
   "source": [
    "# Function to calculate BMI\n",
    "def calculate_bmi(weight, height):\n",
    "    bmi = weight / (height ** 2)\n",
    "    return bmi\n",
    "# Input weight and height from user\n",
    "weight = float(input(\"Enter your weight in kilograms: \"))\n",
    "height = float(input(\"Enter your height in meters: \"))\n",
    "# Calculate BMI\n",
    "bmi = calculate_bmi(weight, height)\n",
    "# Determine BMI category using if-else statements\n",
    "if bmi < 18.5:\n",
    "    category = \"Underweight\"\n",
    "elif 18.5 <= bmi < 24.9:\n",
    "    category = \"Normal Weight\"\n",
    "elif 25 <= bmi < 29.9:\n",
    "    category = \"Overweight\"\n",
    "else:\n",
    "    category = \"Obese\"\n",
    "# Display the BMI and category\n",
    "print(\"Your BMI is: {:.2f}\".format(bmi))\n",
    "print(\"You are categorized as:\", category)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da4381b3-fe88-4eb0-af6d-07fc6658c47d",
   "metadata": {},
   "source": [
    "### 23.How can you use the \"filter()\" function with if-else statements to filter elements from a list?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ae192781-8211-4136-88b7-ea818c105a33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Sample list of numbers\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "# Function to filter even numbers using if-else statement\n",
    "def filter_even(num):\n",
    "    if num % 2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "# Using filter() with the custom function to filter even numbers\n",
    "filtered_numbers = list(filter(filter_even, numbers))\n",
    "print(filtered_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c642b4a1-95e0-45cc-ac0d-6fc84e9db743",
   "metadata": {},
   "source": [
    "### 24.Write a Python program to determine if a given number is prime or not using if-else.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0103ba72-904b-43c8-a0c1-b9add75dbe8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55 is not a prime number.\n"
     ]
    }
   ],
   "source": [
    "# Function to check if a number is prime\n",
    "def is_prime(number):\n",
    "    if number <= 1:\n",
    "        return False\n",
    "    elif number == 2:\n",
    "        return True\n",
    "    elif number % 2 == 0:\n",
    "        return False\n",
    "    else:\n",
    "        # Check for factors from 3 to the square root of the number\n",
    "        for i in range(3, int(number**0.5) + 1, 2):\n",
    "            if number % i == 0:\n",
    "                return False\n",
    "        return True\n",
    "# Get user input\n",
    "num = int(input(\"Enter a number: \"))\n",
    "# Check if the number is prime using the is_prime function\n",
    "if is_prime(num):\n",
    "    print(num, \"is a prime number.\")\n",
    "else:\n",
    "    print(num, \"is not a prime number.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77cbcf1a-751b-4b7c-8537-ffa9149019d1",
   "metadata": {},
   "source": [
    "# Map :-\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db74c7ac-9cbc-4355-9ab6-1abb1409075e",
   "metadata": {},
   "source": [
    "### 1.Explain the purpose of the `map()` function in Python and provide an example of how it can be used to apply a function to each element of an iterable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d28c9dc-d58e-4700-97b2-81d6081b6f0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7f78e450a110>\n",
      "(1, 4, 9, 16, 25, 36)\n"
     ]
    }
   ],
   "source": [
    "def mul(i):    # define a function name.\n",
    "    return i*i  # return the value.\n",
    "num=[1,2,3,4,5,6]      # initilize the value.\n",
    "res=map(mul,num)\n",
    "print(res)\n",
    "mul_output=tuple(res)\n",
    "print(mul_output)          # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4786dfbe-0d26-4717-b7c4-20396d2c4e7b",
   "metadata": {},
   "source": [
    "### 2. Write a Python program that uses the `map()` function to square each element of a list of numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dc7dabf2-a489-4d95-97c9-5d531c0acf7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7f78e4508c40>\n",
      "the squared elements of a list is:\n",
      "[4, 3125, 823543, 46656, 256]\n"
     ]
    }
   ],
   "source": [
    "def square_num(i): # define a fuction.\n",
    "    return i**i\n",
    "num=[2,5,7,6,4]    # take list with values.\n",
    "res=map(square_num,num)  # using map function.\n",
    "print(res)\n",
    "print(\"the squared elements of a list is:\")\n",
    "print(list(res)) # call the map function and print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32480e9b-11f1-45eb-a456-7c7cf367f268",
   "metadata": {},
   "source": [
    "### 3.How does the `map()` function differ from a list comprehension in Python, and when would you choose one over the other?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "49732aa2-078a-4bff-86b6-68c9ecc13c84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = map(lambda x: x**2, numbers)\n",
    "# squared_numbers is an iterator, you can convert it to a list if needed\n",
    "result = list(squared_numbers)\n",
    "print(result)  # Output: [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3d5dcb08-b49a-4395-8103-e2c0c5b6b0dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = [x**2 for x in numbers]\n",
    "print(squared_numbers)  # Output: [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38f0677b-8983-4a78-aba6-7cc1ed8abd1d",
   "metadata": {},
   "source": [
    "### 4.Create a Python program that uses the `map()` function to convert a list of names to uppercase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "164fb5c3-65dc-4a7c-955f-013baec6e4c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7f78e4721c90>\n",
      "['R', 'A', 'M', 'A', 'K', 'R', 'I', 'S', 'H', 'N', 'A', ' ', 'P', 'W', 'S', 'K', 'I', 'L', 'L', 'S']\n"
     ]
    }
   ],
   "source": [
    "def upper_names(i):  # define a function.\n",
    "    return i.upper()  # return the names to uppercase.\n",
    "stri=\"ramakrishna pwskills\"  # initiize the string.\n",
    "res=map(upper_names,stri) # iterate the names using map function.\n",
    "print(res)\n",
    "print(list(res)) # convert the list and print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "659465d9-a7a3-4cdf-b8f2-7a80fe6a789b",
   "metadata": {},
   "source": [
    "### 5.Write a Python program that uses the `map()` function to calculate the length of each word in a list of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4202ae38-1e30-449d-ab91-d9e3bbad94c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the length of a words are: [5, 11]\n"
     ]
    }
   ],
   "source": [
    "def find_len(a): # define function.\n",
    "    s=a.split() \n",
    "    slength=list(map(len,s))  # using map function to iterate the list. \n",
    "    return slength\n",
    "a=\"hello ramakrishna\" # initilize the a value.\n",
    "result=find_len(a)\n",
    "print(\"the length of a words are:\",result) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dfd3521-b4bc-4bfa-995e-3e5a9b844430",
   "metadata": {},
   "source": [
    "### 6.How can you use the `map()` function to apply a custom function to elements of multiple lists simultaneously in Python?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "076ebc92-064c-47b7-bcab-e9f4faaf1d0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8, 10, 12]\n"
     ]
    }
   ],
   "source": [
    "# Custom function to add elements from two lists\n",
    "def add_elements(x, y):\n",
    "    return x + y\n",
    "# Two input lists\n",
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [5, 6, 7, 8]\n",
    "# Use map() to apply the custom function to elements of both lists\n",
    "result = map(add_elements, list1, list2)\n",
    "# Convert the result iterator to a list and print the output\n",
    "output_list = list(result)\n",
    "print(output_list)  # Output: [6, 8, 10, 12]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ea9ba29-522d-455b-8be3-c6d8398972ad",
   "metadata": {},
   "source": [
    "### 7.Create a Python program that uses `map()` to convert a list of temperatures from Celsius to Fahrenheit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cdec238d-f950-491d-a1a3-38bb876386f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperatures in Celsius: [20, 25, 30, 35, 40]\n",
      "Temperatures in Fahrenheit: [68.0, 77.0, 86.0, 95.0, 104.0]\n"
     ]
    }
   ],
   "source": [
    "                                     # Custom function to convert Celsius to Fahrenheit\n",
    "def celsius_to_fahrenheit(celsius):\n",
    "    return (celsius * 9/5) + 32\n",
    "                                      # List of temperatures in Celsius\n",
    "celsius_temperatures = [20, 25, 30, 35, 40]\n",
    "                                     # Use map() to convert temperatures from Celsius to Fahrenheit\n",
    "fahrenheit_temperatures = list(map(celsius_to_fahrenheit, celsius_temperatures))\n",
    "                                    # Print the original and converted temperatures\n",
    "print(\"Temperatures in Celsius:\", celsius_temperatures)\n",
    "print(\"Temperatures in Fahrenheit:\", fahrenheit_temperatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890ff6e3-22db-4cc8-a430-b2987912f3fb",
   "metadata": {},
   "source": [
    "### 8.Write a Python program that uses the `map()` function to round each element of a list of floating-point numbers to the nearest integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "57b5b81a-e644-4a48-85b6-a748ededa168",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Numbers: [3.14, 2.718, 1.618, 4.669, 5.432]\n",
      "Rounded Numbers: [3, 3, 2, 5, 5]\n"
     ]
    }
   ],
   "source": [
    "                                              # List of floating-point numbers\n",
    "float_numbers = [3.14, 2.718, 1.618, 4.669, 5.432]\n",
    "                                              # Use map() to round each element to the nearest integer\n",
    "rounded_numbers = list(map(round, float_numbers))\n",
    "                                              # Print the original and rounded numbers\n",
    "print(\"Original Numbers:\", float_numbers)\n",
    "print(\"Rounded Numbers:\", rounded_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11d16235-1281-4ebf-9921-34708e447d7e",
   "metadata": {},
   "source": [
    "# Reduce :-\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "238527d9-a364-4bfb-b259-029d79ffea82",
   "metadata": {},
   "source": [
    "### 1.What is the `reduce()` function in Python, and what module should you import to use it? Provide an example of its basic usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3937d808-78ae-41f3-a62c-8acc018e8302",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the sum of all numbers are: 15\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce       # import the reduce function.\n",
    "def sum_num(x,y):                \n",
    "    return x+y                     # return the values of x and y.\n",
    "numbers=[1,2,3,4,5]\n",
    "summative=reduce(sum_num,numbers)   # iterate the numbers and sum it using reduce function.\n",
    "print(\"the sum of all numbers are:\",summative) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5986ae9b-bfbb-46ea-937d-5c176d559e1e",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the `reduce()` function to find the product of all elements in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8b03ece4-97cb-4d62-aeb6-3acc1b28e2a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the product of all elements are: 3360\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce  # import the reduce function.\n",
    "def multiply(a,b):\n",
    "    return a*b                   # return the values of a and b. \n",
    "num=[4,7,5,8,3]\n",
    "product=reduce(multiply,num)     # iterate the numbers and multiply it using reduce function.\n",
    "print(\"the product of all elements are:\",product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c94023-fe8e-499e-b188-b5f28a0cb4d2",
   "metadata": {},
   "source": [
    "### 3.Create a Python program that uses `reduce()` to find the maximum element in a list of numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7f4895c7-a16b-4a17-b168-2367bc6c657f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum numbers are in a list is: 12\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "# List of numbers\n",
    "numbers = [3, 8, 1, 5, 12, 7]\n",
    "# Use reduce() to find the maximum element in the list\n",
    "max_number = reduce(lambda x, y: x if x > y else y, numbers)\n",
    "# Print the maximum number\n",
    "print(\"Maximum numbers are in a list is:\", max_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3f4edc8-b62c-431b-9801-dbca038e79ff",
   "metadata": {},
   "source": [
    "### 4.How can you use the `reduce()` function to concatenate a list of strings into a single string?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d22875e4-9e82-4e72-88fb-0d897909be17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the concatenate string is: ['r', 'a', 'm', 'a', 'k', 'r', 'i', 's', 'h', 'n', 'a']\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce  # import reduce function.\n",
    "def concate_str(a,b):          # create a function.\n",
    "    return a + b\n",
    "a=\"rama\"                # initilize two strings.\n",
    "b=\"krishna\"\n",
    "c=list(reduce(lambda a,b: a+b,[a,b])) \n",
    "print(\"the concatenate string is:\",c) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6dedcfe-f4e6-43eb-80d1-8684d3c666b5",
   "metadata": {},
   "source": [
    "### 5.Write a Python program that calculates the factorial of a number using the `reduce()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "45b14082-5083-4736-8f3d-fb4a18d8d443",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "import functools # import reduce function.\n",
    "def factorial(n):   # define function.\n",
    "    if n == 0: \n",
    "        return 1   # if condition is true return 1.\n",
    "    else:\n",
    "        return functools.reduce(lambda x,y: x*y, range(1,n+1))\n",
    "print(factorial(3)) # print the reslut."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fe0e963-3982-4b77-838e-74b290fd1b49",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that uses `reduce()` to find the GCD (Greatest Common Divisor) of a list of numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "938aa224-2248-4114-9f9e-cabc73f182a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of the list [12, 24, 36, 48] is: 12\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "import math\n",
    "# Function to find GCD of two numbers\n",
    "def find_gcd(x, y):\n",
    "    return math.gcd(x, y)\n",
    "# Function to find GCD of a list of numbers using reduce\n",
    "def find_gcd_of_list(numbers):\n",
    "    # Use reduce() to apply find_gcd() on the list of numbers\n",
    "    result = reduce(find_gcd, numbers)\n",
    "    return result\n",
    "# Example list of numbers\n",
    "numbers = [12, 24, 36, 48]\n",
    "# Find GCD of the list of numbers\n",
    "gcd_result = find_gcd_of_list(numbers)\n",
    "# Output the result\n",
    "print(\"GCD of the list\", numbers, \"is:\", gcd_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "268a981a-5a6f-416b-b371-05ab26377aec",
   "metadata": {},
   "source": [
    "### 7.Write a Python program that uses the `reduce()` function to find the sum of the digits of a given number.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9ac37434-b1d4-4a20-a265-c963b174b912",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter numbers 123\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of digits of 12345 is: 6\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce # import reduce.\n",
    "def sum_of_digits(numbers):           # define function.\n",
    "    digits=list(map(int, str(numbers)))        # convert numbers to digits.\n",
    "    total_sum = reduce(lambda x, y: x + y,digits)  # sum of all digits.\n",
    "    return total_sum\n",
    "numbers=int(input(\"enter numbers\"))\n",
    "result=sum_of_digits(numbers)\n",
    "print(\"Sum of digits of\", number, \"is:\", result) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ee06a75-35ab-4fc6-b81e-74b41c60a68f",
   "metadata": {},
   "source": [
    "# Filter :-\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27bfb833-7dd6-4f27-8792-635aa37f8e71",
   "metadata": {},
   "source": [
    "### 1.Explain the purpose of the `filter()` function in Python and provide an example of how it can be used to filter elements from an iterable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ef881b20-6c86-4673-b189-da9f9f6e1e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "def is_odd(num):          # define a function.\n",
    "    return num%2!=0         # return the odd numbers code.\n",
    "numbers=[1,2,3,4,5,6,7,8]\n",
    "odd_num=filter(is_odd,numbers) # using filter to iterate the value.\n",
    "print(list(odd_num)) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "751731bd-d985-4b73-a7d1-438814aa0435",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the `filter()` function to select even numbers from a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "26fac279-caa4-42db-bd38-a4f652830a85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 8, 2]\n"
     ]
    }
   ],
   "source": [
    "def is_even(num):             # define a function.\n",
    "    return num%2==0                    # return the odd numbers code.\n",
    "numbers=[5,4,7,8,9,2,3]\n",
    "even_num=filter(is_even,numbers)  # using filter to iterate the value.\n",
    "print(list(even_num))  # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6364e88-c142-4059-8c34-dcf650acbb37",
   "metadata": {},
   "source": [
    "### 3.Create a Python program that uses the `filter()` function to select names that start with a specific letter from a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c2c4d2a0-72ea-4b5e-a2cf-a5a30884ebcd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Charlie']\n"
     ]
    }
   ],
   "source": [
    "# Define a function to filter names starting with a specific letter\n",
    "def starts_with_letter(letter, names):\n",
    "    return filter(lambda name: name.startswith(letter), names)\n",
    "# List of names\n",
    "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eva\", \"Frank\", \"Grace\"]\n",
    "# Letter to filter names by\n",
    "selected_letter = \"C\"\n",
    "# Use filter() to select names starting with the specified letter\n",
    "filtered_names = starts_with_letter(selected_letter, names)\n",
    "# Convert the filtered result to a list and print it\n",
    "print(list(filtered_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "923816ff-8ea5-4cb2-8fbe-3ca1e9195647",
   "metadata": {},
   "source": [
    "### 4.Write a Python program that uses the `filter()` function to select prime numbers from a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4086d450-5a1a-4136-9d64-635e2fff3060",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "def is_prime(n):         # define a function.\n",
    "    if n<2:\n",
    "        return False\n",
    "    for i in range(2,int(n**0.5)+1): # iterate i value for prime number\n",
    "        if n%i==0:\n",
    "            return False\n",
    "        return True\n",
    "limit=10\n",
    "res=list(filter(is_prime,range(limit+1)))# print the result.\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72a7fcff-2ea1-4ce9-99b7-30a05065da4f",
   "metadata": {},
   "source": [
    "### 5.How can you use the `filter()` function to remove None values from a list in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b587eb68-fbd8-4106-97b2-5a67dc633f26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list is : [1, None, 4, None, None, 5, 8, None, False]\n",
      "List after removal of None values : [1, 4, 5, 8, False]\n"
     ]
    }
   ],
   "source": [
    "# initializing list\n",
    "test_list = [1, None, 4, None, None, 5, 8, None, False]\n",
    "# printing original list\n",
    "print (\"The original list is : \" + str(test_list))\n",
    "# using filter()\n",
    "# to remove None values in list\n",
    "res = list(filter(lambda item: item is not None, test_list))\n",
    "# printing result\n",
    "print (\"List after removal of None values : \" + str(res))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fce5da4-95e1-4707-9acf-5ff6b45e1f68",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that uses `filter()` to select words longer than a certain length from a list of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b61be671-f2fc-40ba-9ed0-82744f571939",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words longer than 5 characters: ['banana', 'orange', 'pineapple']\n"
     ]
    }
   ],
   "source": [
    "# Function to filter words based on length\n",
    "def filter_words(words, length):\n",
    "    return list(filter(lambda word: len(word) > length, words))\n",
    "# List of strings\n",
    "word_list = [\"apple\", \"banana\", \"grape\", \"kiwi\", \"orange\", \"pineapple\"]\n",
    "# Length threshold for filtering words\n",
    "length_threshold = 5\n",
    "# Filter words longer than the specified length\n",
    "filtered_words = filter_words(word_list, length_threshold)\n",
    "# Print the filtered words\n",
    "print(f\"Words longer than {length_threshold} characters: {filtered_words}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc526eac-6ac4-4646-8e24-813ef7b307f1",
   "metadata": {},
   "source": [
    "### 7.Write a Python program that uses the `filter()` function to select elements greater than a specified threshold from a list of values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d0713d6e-2b5f-4ca0-963b-ba4d6e6e0c48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elements greatherthan 5 characters: ['banana', 'orange', 'pineapple']\n"
     ]
    }
   ],
   "source": [
    "def filter_elements(elements,length):            # Function to filter words based on length\n",
    "    return list(filter(lambda element:len(element)>length,elements))\n",
    "elements= [\"apple\", \"banana\", \"grape\", \"kiwi\", \"orange\", \"pineapple\"]\n",
    "length_threshold = 5# Length threshold for filtering words\n",
    "filtered_elements = filter_elements(elements, length_threshold)\n",
    "print(f\"elements greatherthan {length_threshold} characters: {filtered_elements}\") # Print the filtered words"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ea6d58-4310-40ee-a0db-9e78d55f628a",
   "metadata": {},
   "source": [
    "# Recursion:-\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dda1209e-385c-4af6-95e5-e8c3822aee2f",
   "metadata": {},
   "source": [
    "### 1.Explain the concept of recursion in Python. How does it differ from iteration?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0314a3b2-e4d3-499d-96cb-e2a010d7bddb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def find_len(n):  # define function.\n",
    "    if n==\"\":         # if condition satisfy return 0\n",
    "        return 0\n",
    "    else:\n",
    "        return 1+find_len(n[1:]) \n",
    "find_len(\"rama\")  # int the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb0ea33c-95b4-4466-87ca-b1eac0667c04",
   "metadata": {},
   "source": [
    "### 2.Write a Python program to calculate the factorial of a number using recursion.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1cad8a06-d392-464a-9c73-1c620ef07835",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " the factorial of 8 is: {40320}\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):  # define function.\n",
    "    if n==0:# if condition satisfy return 1\n",
    "        return 1\n",
    "    else:\n",
    "        return n*factorial(n-1)\n",
    "result=factorial(8)\n",
    "print(f\" the factorial of 8 is:\",{result})  # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68214d42-6fab-4cdc-8d9a-195fcb128603",
   "metadata": {},
   "source": [
    "### 3.Create a recursive Python function to find the nth Fibonacci number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e7f4e6c7-c113-4513-9872-17cbadf97208",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a number 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5th Fibonacci number is: 3\n"
     ]
    }
   ],
   "source": [
    "def fibonacci(n):  # define a function.\n",
    "    if n<=0:\n",
    "        return \"invalid input\"\n",
    "    elif n==1:\n",
    "        return 0 # using if else if to find the fibonacci of a number.\n",
    "    elif n==2:\n",
    "        return 1\n",
    "    else:\n",
    "        return fibonacci(n-1)+fibonacci(n-2)\n",
    "n=int(input(\"enter a number\")) # Driver code.\n",
    "result=fibonacci(n)\n",
    "print(f\"The {n}th Fibonacci number is: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17b82d23-a4a4-4466-8b22-75eafac36e77",
   "metadata": {},
   "source": [
    "### 4.Write a recursive Python function to calculate the sum of all elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8785566b-5538-4d79-a765-c92bd453e8d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the sum of all elements is 21\n"
     ]
    }
   ],
   "source": [
    "def sum_of_elements(a): # define function.\n",
    "    if not a:\n",
    "        return 0\n",
    "    else:\n",
    "        return a[0]+sum_of_elements(a[1:]) # summative of all elements in a list.\n",
    "a=[1,2,3,4,5,6] # driver code.\n",
    "res=sum_of_elements(a)\n",
    "print(f\"the sum of all elements is {res}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df168a1-6970-4a7a-bda3-42f89c5e0143",
   "metadata": {},
   "source": [
    "### 5.How can you prevent a recursive function from running indefinitely, causing a stack overflow error?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "74879813-7339-4ce4-9e00-84ae6e3ff3a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of 5 (using recursion) is: 120\n"
     ]
    }
   ],
   "source": [
    "def factorial_recursive(n): # define the function.\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial_recursive(n - 1) # factorial of a recursive function.\n",
    "# driver code.\n",
    "number = 5\n",
    "result_recursive = factorial_recursive(number)\n",
    "print(f\"Factorial of {number} (using recursion) is: {result_recursive}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76e87443-7721-4e8e-a670-9797936abdf5",
   "metadata": {},
   "source": [
    "### 6.Create a recursive Python function to find the greatest common divisor (GCD) of two numbers using the Euclidean algorithm.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3f4fd281-78f1-4222-b61e-7aa162937919",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of 48 and 18 is: 6\n"
     ]
    }
   ],
   "source": [
    "def gcd(a, b): # define a function.\n",
    "    if b == 0:\n",
    "        return a\n",
    "    else:\n",
    "        return gcd(b, a % b)\n",
    "                            # driver code.\n",
    "num1 = 48\n",
    "num2 = 18\n",
    "result = gcd(num1, num2)\n",
    "print(f\"GCD of {num1} and {num2} is: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218588dd-93c2-446d-974e-1c55eac4ec38",
   "metadata": {},
   "source": [
    "### 7.Write a recursive Python function to reverse a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f3d52885-51b1-4332-9812-2df82bb2c720",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String: Hello, World!\n",
      "Reversed String: !dlroW ,olleH\n"
     ]
    }
   ],
   "source": [
    "def reverse_string(input_str):\n",
    "    # Base case: if the string is empty or has only one character, return the string itself\n",
    "    if len(input_str) <= 1:\n",
    "        return input_str\n",
    "    # Recursive step: reverse the substring starting from the second character and concatenate the first character\n",
    "    return reverse_string(input_str[1:]) + input_str[0]\n",
    "# driver usage\n",
    "original_string = \"Hello, World!\"\n",
    "reversed_string = reverse_string(original_string)\n",
    "print(\"Original String:\", original_string)\n",
    "print(\"Reversed String:\", reversed_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe7e7bf-4b19-4e88-b765-81dbc7222a45",
   "metadata": {},
   "source": [
    "### 8.Create a recursive Python function to calculate the power of a number (x^n).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fb6b7211-b940-4849-bc6c-13e3b1391d0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter n value 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000\n"
     ]
    }
   ],
   "source": [
    "def power_of_number(x,n): # define a function.\n",
    "    if x==1:\n",
    "        return x\n",
    "    else:\n",
    "        return x**n   \n",
    "x=10                       # driver code.\n",
    "n=int(input(\"enter n value\")) \n",
    "res=power_of_number(x,n) # function calling.\n",
    "print(res)            # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6f32421-cd87-46c9-9ba0-29c2b8027f76",
   "metadata": {},
   "source": [
    "### 9.Write a recursive Python function to find all permutations of a given string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "02109658-75fa-46de-9725-e798f9e39ec8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 'abdc', 'acbd', 'acdb', 'adbc', 'adcb', 'bacd', 'badc', 'bcad', 'bcda', 'bdac', 'bdca', 'cabd', 'cadb', 'cbad', 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca', 'dcab', 'dcba']\n"
     ]
    }
   ],
   "source": [
    "def permute(s):\n",
    "  out = []\n",
    "  if len(s) == 1:\n",
    "    return s\n",
    "  else:\n",
    "    for i,let in enumerate(s):\n",
    "      for perm in permute(s[:i] + s[i+1:]):\n",
    "        out += [let + perm]\n",
    "  return out\n",
    "l = permute(['a','b','c','d'])\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9327b0-dc14-4c43-b968-e7c2095f0ff2",
   "metadata": {},
   "source": [
    "### 10.Write a recursive Python function to check if a string is a palindrome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2cf6296e-0d25-4a5a-be11-86ae1a4192c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "palindrome\n"
     ]
    }
   ],
   "source": [
    "def palindrome(s):      # define a function.\n",
    "    if s==s[::-1]:\n",
    "        return 'palindrome' # return the statement.\n",
    "    else:\n",
    "        return 'not a palindrome'\n",
    "s='madam'       # assign a value.\n",
    "res=palindrome(s)\n",
    "print(res) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9f1b33-e7ec-43c1-a0eb-d0414cdba82d",
   "metadata": {},
   "source": [
    "### 11.Create a recursive Python function to generate all possible combinations of a list of elements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5fbf18b0-7ad4-42e4-ba49-290cb2b7ae1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1234', '1243', '1324', '1342', '1423', '1432', '2134', '2143', '2314', '2341', '2413', '2431', '3124', '3142', '3214', '3241', '3412', '3421', '4123', '4132', '4213', '4231', '4312', '4321']\n"
     ]
    }
   ],
   "source": [
    "def permute(s):  # define a function.\n",
    "  out = []        # take a empty list.\n",
    "  if len(s) == 1:\n",
    "    return s  # return statement.\n",
    "  else:\n",
    "    for i,let in enumerate(s):\n",
    "      for perm in permute(s[:i] + s[i+1:]): # iterate the s value.\n",
    "        out += [let + perm]\n",
    "  return out\n",
    "l = permute(['1','2','3','4'])\n",
    "print(l) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27fe2820-2968-4a3a-a91e-5cec99d5cafe",
   "metadata": {},
   "source": [
    "# Basics of Functions:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7758c9c6-c4c1-41d0-a1fb-d90b5174a2e3",
   "metadata": {},
   "source": [
    "### 1.What is a function in Python, and why is it used?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0fcd2e0f-8db4-4650-9f66-62f385dc6e91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 10 is 3628800\n"
     ]
    }
   ],
   "source": [
    "# Define a recursive function to calculate the factorial of a number\n",
    "def factorial(n):\n",
    "    if n == 0:  # Base case: factorial of 0 is 1\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)  # Recursive case: n! = n * (n-1)!\n",
    "\n",
    "# Example usage of the factorial function\n",
    "number = 10\n",
    "# You can change this number to calculate the factorial of a different value\n",
    "result = factorial(number)\n",
    "print(f\"The factorial of {number} is {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1cc562-f305-4e0f-aab3-b28614f6bfd1",
   "metadata": {},
   "source": [
    "### 2.How do you define a function in Python? Provide an example.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "25a1c220-75c4-4ea2-9bac-cce9d5f61e10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def power_of_number(x,n): # define a function.\n",
    "    if x==1:           # condition is true return 1.\n",
    "        return 1\n",
    "    else:\n",
    "        return x**n # else return x^n\n",
    "x=5\n",
    "n=2              # assign the n and x values.\n",
    "print(power_of_number(x,n)) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "692d8f71-5fb8-4cd5-8a39-7130f0cbda12",
   "metadata": {},
   "source": [
    "### 3.Explain the difference between a function definition and a function call.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a83a7f96-5525-4f1b-9469-3d3f304f9ec4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56088"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def product(a,b): # function definition .\n",
    "    return a*b  # return the value.\n",
    "a=123\n",
    "b=456 # take a values.\n",
    "product(a,b) # function call."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "888f3a6e-23e8-470f-87e8-bc155955c718",
   "metadata": {},
   "source": [
    "### 4.Write a Python program that defines a function to calculate the sum of two numbers and then calls the function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d586d0ce-2254-42f1-83f2-2446354a4992",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n"
     ]
    }
   ],
   "source": [
    "def sum_of_two_values(x,y): # define a function.\n",
    "    return x+y # return the sum of two numbers.\n",
    "x=78 \n",
    "y=21 # take values.\n",
    "print(sum_of_two_values(x,y)) # print the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9163e8b3-e942-4276-85ca-94e9d915986d",
   "metadata": {},
   "source": [
    "### 5.What is a function signature, and what information does it typically include?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "64083051-82a9-4a4a-89f1-5ca1501411a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(x: str, y: int)\n",
      "x: str\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "from inspect import signature \n",
    "# declare a function gfg with some \n",
    "# parameter \n",
    "def gfg(x:str, y:int): \n",
    "\tpass\n",
    "# with the help of signature function \n",
    "# store signature of the function in \n",
    "# variable t \n",
    "t = signature(gfg) \n",
    "# print the signature of the function \n",
    "print(t) \n",
    "# print the annonation of the parameter \n",
    "# of the function \n",
    "print(t.parameters['x']) \n",
    "# print the annonation of the parameter \n",
    "# of the function \n",
    "print(t.parameters['y'].annotation) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "248faf1d-9258-4a6e-80b5-866ba6f86429",
   "metadata": {},
   "source": [
    "### 6.Create a Python function that takes two arguments and returns their product.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b6d38492-4594-4305-80b9-c7d3df4fd70c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def product(arg1,arg2): # function definition .\n",
    "    return arg1*arg2  # return the value.\n",
    "arg1=12\n",
    "arg2=4# take a values.\n",
    "product(arg1,arg2) # function call."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9406cc98-42d2-4f24-800d-828b95f3dd37",
   "metadata": {},
   "source": [
    "# Function Parameters and Arguments:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae95e009-96b2-4094-b77c-3fcf59116f3b",
   "metadata": {},
   "source": [
    "### 1.Explain the concepts of formal parameters and actual arguments in Python functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e31ebc6b-5de5-4a23-b55e-0d1f4c429fbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def sum(a, b): #a, b are formal arguments\n",
    "    c = a+b \n",
    "    print(c)\n",
    "\n",
    "#call the function \n",
    "x = 10; y = 15\n",
    "sum(x, y) #x, y are actual arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3724419e-9f47-478a-8559-4a5af3fd44c9",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that defines a function with default argument values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "571b7686-5aee-48f7-aec9-7c957983a423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Guest!\n",
      "Hello, John!\n",
      "Hi, Alice!\n"
     ]
    }
   ],
   "source": [
    "# Step 1: Define a function with default arguments\n",
    "def greet(name=\"Guest\", greeting=\"Hello\"):\n",
    "    # Step 3: Function logic\n",
    "    message = f\"{greeting}, {name}!\"\n",
    "    print(message)\n",
    "# Step 4: Calling the function\n",
    "greet()  # Uses default values for both name and greeting\n",
    "greet(\"John\")  # Uses the default value for greeting (\"Hello\")\n",
    "greet(\"Alice\", \"Hi\")  # Uses specific values for both name and greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33cd1571-5cb2-4421-bf15-9eb096a51be2",
   "metadata": {},
   "source": [
    "### 3.How do you use keyword arguments in Python function calls? Provide an example.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fa9967ec-6c0d-4b91-8b1d-deb7d77ec454",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n",
      "Hi, Bob!\n",
      "Hello, Charlie!!!\n"
     ]
    }
   ],
   "source": [
    "def greet(name, greeting='Hello', punctuation='!'):\n",
    "    \"\"\"A function that greets a person.\"\"\"\n",
    "    print(f\"{greeting}, {name}{punctuation}\")\n",
    "# Using positional arguments\n",
    "greet('Alice')  # Hello, Alice!\n",
    "# Using keyword arguments\n",
    "greet(name='Bob', greeting='Hi')  # Hi, Bob!\n",
    "# Mixing positional and keyword arguments\n",
    "greet('Charlie', punctuation='!!!')  # Hello, Charlie!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52a74a74-209c-4196-aa5a-0220d44fd2cc",
   "metadata": {},
   "source": [
    "### 4.Create a Python function that accepts a variable number of arguments and calculates their sum.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "600870b3-d5db-4da8-b7ef-92a5cb03ed8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Sum(a,b): # define a function a arguments.\n",
    "    return c # return variable.\n",
    "a=10 # take a values.\n",
    "b=50\n",
    "c=a+b # accepts variable number of arguments.\n",
    "Sum(a,b) # function call."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed1c352b-e3d1-413a-b907-6f708a20cb63",
   "metadata": {},
   "source": [
    "### 5.What is the purpose of the `*args` and `**kwargs` syntax in function parameter lists?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0cb1aeae-194b-40de-aebc-c808638f075a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "def sum_values(*args):\n",
    "    result = 0\n",
    "    for value in args:\n",
    "        result += value\n",
    "    return result\n",
    "print(sum_values(1, 2, 3, 4, 5))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "815f6463-7b34-4ce5-ac9a-efe8aaba8d70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Alice\n",
      "age: 30\n",
      "city: Wonderland\n"
     ]
    }
   ],
   "source": [
    "def print_info(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"{key}: {value}\")\n",
    "print_info(name='Alice', age=30, city='Wonderland')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d31dbd90-06d4-453b-b287-c6d6eba28ca7",
   "metadata": {},
   "source": [
    "## Return Values and Scoping:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b53dd44-2af1-4be0-ad68-b9eee66691a0",
   "metadata": {},
   "source": [
    "### 1.Describe the role of the `return` statement in Python functions and provide examples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "792cd436-f6a9-4ed3-a972-0b9a1dcfe0f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To return the value that is 30\n"
     ]
    }
   ],
   "source": [
    "# define the funmction name as add.\n",
    "def add(a,b):\n",
    "# using return statement which is used return the values.\n",
    "    return(a+b)\n",
    "# print the result.\n",
    "print(\"To return the value that is\",add(10,20))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a90b2e7b-2547-4850-88c2-646dd95f915e",
   "metadata": {},
   "source": [
    "### 2.Explain the concept of variable scope in Python, including local and global variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9b50b192-cf0e-4659-bbdf-4846358ea2a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using global variable.\n",
    "global_variable=5\n",
    "# Define the function name as 'example'.\n",
    "def example():\n",
    "    print(global_variable)\n",
    "# Print the result.\n",
    "example()\n",
    "\n",
    "\n",
    "# using local variable.\n",
    "def lo_example():\n",
    "# Local varible creation.\n",
    "    local_variable=45\n",
    "# Print the result.\n",
    "    return(local_variable)\n",
    "lo_example()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fcd46ca-794b-4e2e-a9d9-d1b4ddd45409",
   "metadata": {},
   "source": [
    "### 3.Write a Python program that demonstrates the use of global variables within functions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2274f956-9ec3-4943-93dc-420c1fe2c38f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using global variable and assign value as 80.\n",
    "global_variable=80\n",
    "# Define the function name for global variable.\n",
    "def modify_global_variable():\n",
    "# global variable is used to modify the value of a global varible within the function.\n",
    "    global global_variable\n",
    "    global_variable=20\n",
    "# Return the value.\n",
    "    return(global_variable)\n",
    "# function calling.\n",
    "modify_global_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f3d26b4-4ba9-44ad-b584-9683a060bafc",
   "metadata": {},
   "source": [
    "### 4.Create a Python function that calculates the factorial of a number and returns it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9e47fbc3-cb99-412a-83b3-1ff882f5af95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 4 is: 24\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "# Calculate the factorial of a number.\n",
    "    if n < 0:\n",
    "        raise ValueError(\"Factorial is not defined for negative numbers.\")\n",
    "    elif n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        result = 1\n",
    "        for i in range(2, n + 1):\n",
    "            result *= i\n",
    "        return result\n",
    "# Example usage:\n",
    "number = 4\n",
    "result = factorial(number)\n",
    "print(f\"The factorial of {number} is: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22816126-321f-44fc-9a9b-eb572822ebb9",
   "metadata": {},
   "source": [
    "### 5.How can you access variables defined outside a function from within the function?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "39712f91-b0ed-4e82-9aad-981932863e15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using global variable and assign value as 80.\n",
    "global_variable=80\n",
    "# Define the function name for global variable.\n",
    "def modify_global_variable():\n",
    "# global variable is used to modify the value of a global varible within the function.\n",
    "    global global_variable\n",
    "    global_variable=20\n",
    "# Return the value.\n",
    "    return(global_variable)\n",
    "# function calling.\n",
    "modify_global_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10af94c-fb60-467b-8276-d5cfb9329c44",
   "metadata": {},
   "source": [
    "## Lambda Functions and Higher-Order Functions:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccfaeb92-6eb7-468a-a429-55f02dffb733",
   "metadata": {},
   "source": [
    "### 1.What are lambda functions in Python, and when are they typically used?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fb34a4c1-9745-4c49-8898-53c50b40b1ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# Define the function.\n",
    "def mul(a,b):\n",
    "# Return the result.\n",
    "    return result()\n",
    "# Using lambda function.\n",
    "mul=lambda x,y:x*y\n",
    "# Print the result.\n",
    "result=mul(2,5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c5394fc-66a2-45e8-a313-07c93484a944",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses lambda functions to sort a list of tuples based on the second element.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "24c5ea5a-e9bb-456e-ad42-91a5360a2d67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [(1, 5), (3, 2), (2, 8), (4, 1)]\n",
      "Sorted List based on the second element: [(4, 1), (3, 2), (1, 5), (2, 8)]\n"
     ]
    }
   ],
   "source": [
    "# Sample list of tuples\n",
    "tuple_list = [(1, 5), (3, 2), (2, 8), (4, 1)]\n",
    "# Sorting based on the second element of each tuple\n",
    "sorted_tuples = sorted(tuple_list, key=lambda x: x[1])\n",
    "# Displaying the sorted list\n",
    "print(\"Original List:\", tuple_list)\n",
    "print(\"Sorted List based on the second element:\", sorted_tuples)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fed2e613-6f2e-4b55-8632-a87c44d30a98",
   "metadata": {},
   "source": [
    "### 3.Explain the concept of higher-order functions in Python, and provide an example.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2b1db45b-82a8-4a38-a936-474ffa134880",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "# Using Functions as Arguments:\n",
    "def apply_operation(operation, x, y):\n",
    "    return operation(x, y)\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    "result_addition = apply_operation(add, 3, 5)\n",
    "result_multiplication = apply_operation(multiply, 3, 5)\n",
    "print(result_addition)        \n",
    "print(result_multiplication)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ee28a15d-3f03-473d-953a-33079ceb45c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "# Using function as return values.\n",
    "def multiplier(factor):\n",
    "    def multiply(x):\n",
    "        return x * factor\n",
    "    return multiply\n",
    "double = multiplier(2)\n",
    "triple = multiplier(3)\n",
    "print(double(5))  \n",
    "print(triple(5))  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c376f1d-cc00-442a-b096-1bf8b74002eb",
   "metadata": {},
   "source": [
    "### 4.Create a Python function that takes a list of numbers and a function as arguments, applying the function to each element in the list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1e5d58d0-c7f2-447b-93b8-8a480d6d8135",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 3, 4, 5]\n",
      "Squared List: [1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def apply_function_to_list(numbers, custom_function):\n",
    "    result = []\n",
    "    for number in numbers:\n",
    "        result.append(custom_function(number))\n",
    "    return result\n",
    "# Example usage:\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "# Define a custom function (e.g., square)\n",
    "def square(x):\n",
    "    return x ** 2\n",
    "# Apply the custom function to the list of numbers\n",
    "result_squared = apply_function_to_list(numbers, square)\n",
    "print(\"Original List:\", numbers)\n",
    "print(\"Squared List:\", result_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bac8bad0-5b2c-46bc-8a0b-fd28c0bc1eaa",
   "metadata": {},
   "source": [
    "## Built-in Functions:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "020d9749-9449-4493-8072-97aa3f3186e3",
   "metadata": {},
   "source": [
    "### 1.Describe the role of built-in functions like `len()`, `max()`, and `min()` in Python.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "1274f880-c3f2-4b8a-8027-79595c364e88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "9\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# len() function.\n",
    "example_list = [1, 2, 3, 4, 5]\n",
    "length_of_list = len(example_list)\n",
    "print(length_of_list)  \n",
    "\n",
    "# max() function.\n",
    "example_numbers = [3, 7, 1, 9, 4]\n",
    "maximum_number = max(example_numbers)\n",
    "print(maximum_number)  # Outputs: 9\n",
    "\n",
    "# min() function.\n",
    "example_numbers = [3, 7, 1, 9, 4]\n",
    "minimum_number = min(example_numbers)\n",
    "print(minimum_number)  # Outputs: 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cf3930f-6e9e-4c8d-8ad9-c75d74ee55cf",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the `map()` function to apply a function to each element of a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cd272a07-40bf-41e9-8163-1d9461fc60fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 3, 4, 5]\n",
      "Squared List: [1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Example function: Square a number\n",
    "def square(x):\n",
    "    return x ** 2\n",
    "# Example list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "# Use map() to apply the square function to each element in the list\n",
    "squared_numbers = map(square, numbers)\n",
    "# Convert the result to a list (as map() returns an iterator)\n",
    "squared_numbers_list = list(squared_numbers)\n",
    "# Display the original and squared lists\n",
    "print(\"Original List:\", numbers)\n",
    "print(\"Squared List:\", squared_numbers_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf14991f-4b30-440b-8a2f-8afcd9ba64db",
   "metadata": {},
   "source": [
    "### 3.How does the `filter()` function work in Python, and when would you use it?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b16900ad-3167-475f-b2b6-743671e9a555",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Even Numbers List: [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Example function: Check if a number is even\n",
    "def is_even(x):\n",
    "    return x % 2 == 0\n",
    "# Example list of numbers\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "# Use filter() to get the even numbers\n",
    "even_numbers = filter(is_even, numbers)\n",
    "# Convert the result to a list (as filter() returns an iterator)\n",
    "even_numbers_list = list(even_numbers)\n",
    "# Display the original and filtered lists\n",
    "print(\"Original List:\", numbers)\n",
    "print(\"Even Numbers List:\", even_numbers_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84607c0b-84d4-4649-b159-2bf2b3f895f4",
   "metadata": {},
   "source": [
    "### 4.Create a Python program that uses the `reduce()` function to find the product of all elements in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8daf9bc5-b915-411b-8851-7136f503ac4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 3, 4, 5]\n",
      "Product of List Elements: 120\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "import operator\n",
    "# Example list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "# Using reduce() with operator.mul\n",
    "product = reduce(operator.mul, numbers)\n",
    "# Display the original list and the product\n",
    "print(\"Original List:\", numbers)\n",
    "print(\"Product of List Elements:\", product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ef3a473-a593-49ea-9494-a136f5fe9c6c",
   "metadata": {},
   "source": [
    "## Function Documentation and Best Practices:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "283b6264-4a31-4509-bbd9-ceb080f2b9b7",
   "metadata": {},
   "source": [
    "### 1.Explain the purpose of docstrings in Python functions and how to write them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "8dde10cb-32d5-4653-a91e-974e89ff0ea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def example_function(parameter1, parameter2):\n",
    "    \"\"\"\n",
    "    This is a docstring for the example_function.\n",
    "\n",
    "    Parameters:\n",
    "    - parameter1: Description of parameter1\n",
    "    - parameter2: Description of parameter2\n",
    "\n",
    "    Returns:\n",
    "    Description of the return value (if applicable)\n",
    "    \"\"\"\n",
    "    # Function code goes here\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ed4afbc9-bbaf-4e04-974e-6daae970d697",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis is a docstring for the example_module.\\n\\nModule-level details and purpose go here.\\n'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is a docstring for the example_module.\n",
    "\n",
    "Module-level details and purpose go here.\n",
    "\"\"\"\n",
    "# Module code goes here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "dc4a7397-5418-490f-9c26-ee5e8d7325bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExampleClass:\n",
    "    \"\"\"\n",
    "    This is a docstring for the ExampleClass.\n",
    "\n",
    "    Attributes:\n",
    "    - attribute1: Description of attribute1\n",
    "    - attribute2: Description of attribute2\n",
    "\n",
    "    Methods:\n",
    "    - method1(): Description of method1\n",
    "    - method2(): Description of method2\n",
    "    \"\"\"\n",
    "    # Class code goes here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "96ff29cc-9c5e-44fb-99a0-b40674d7187a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function example_function in module __main__:\n",
      "\n",
      "example_function(parameter1, parameter2)\n",
      "    This is a docstring for the example_function.\n",
      "    \n",
      "    Parameters:\n",
      "    - parameter1: Description of parameter1\n",
      "    - parameter2: Description of parameter2\n",
      "    \n",
      "    Returns:\n",
      "    Description of the return value (if applicable)\n",
      "\n",
      "\n",
      "    This is a docstring for the example_function.\n",
      "\n",
      "    Parameters:\n",
      "    - parameter1: Description of parameter1\n",
      "    - parameter2: Description of parameter2\n",
      "\n",
      "    Returns:\n",
      "    Description of the return value (if applicable)\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "help(example_function)\n",
    "print(example_function.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65c94b7b-9b01-43c0-b35a-fa02197f40b6",
   "metadata": {},
   "source": [
    "### 2.Describe some best practices for naming functions and variables in Python, including naming conventions and guidelines.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "e9966ee6-3ade-48e3-ab99-bcf6466f792f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\"\"\"1.Use Descriptive Names:\n",
    "\n",
    "Choose names that clearly convey the purpose of the function or variable.\n",
    "Avoid overly short or cryptic names that may be confusing to others.\n",
    "Follow PEP 8:\n",
    "\n",
    "PEP 8 is the style guide for Python code. Adhering to PEP 8 makes your code more consistent and readable.\n",
    "Function names should be lowercase, with words separated by underscores (snake_case).\n",
    "Variable names should also be lowercase with underscores, unless they are constants, which should be in uppercase with underscores (e.g., MAX_SIZE).\n",
    "Be Consistent:\n",
    "\n",
    "Maintain consistency in naming across your codebase. If you choose a naming style, stick to it.\n",
    "Consistency helps developers easily understand and navigate your code.\n",
    "Use Verb-Noun Naming for Functions:\n",
    "\n",
    "Choose names for functions that indicate the action they perform (verb) followed by the object or subject (noun).\n",
    "This convention makes it clear what the function does.\"\"\"\n",
    "# Good\n",
    "def calculate_total():\n",
    "    pass\n",
    "# Avoid\n",
    "def total_calc():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4e80a6ed-9643-4951-877b-6c18c3fad298",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Good\n",
    "total_amount = 0\n",
    "# Avoid\n",
    "t = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d0bfb5a6-da61-4c7c-8f75-0a6c308a9f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2d100fc6-b79b-45e8-9432-777548b23cd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def example_function():\n",
    "    local_variable = 5\n",
    "    # ...\n",
    "\n",
    "global_variable = 10"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}