17th_ Sept_Python_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61bb8e61-1e79-4273-bec2-8c738185d260",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89e510fb-11ea-4928-bd82-0497344af911",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "                                                             ****Python Assignment****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5f505f6-6127-4664-ac2a-06544b910b05",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "713d23d9-2ae7-40a3-bed9-b7a98b171792",
   "metadata": {},
   "source": [
    "### For Loop:-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8363797-eebf-47b5-8f3b-37be5996aab2",
   "metadata": {},
   "source": [
    "### 1.Write a Python program to prints numbers from 1 to 10 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d9f27590-36d3-4386-84a9-129044f72a40",
   "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": [
    "\n",
    "for i in range(1,11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dab6dd9d-ed43-4ace-bb34-9675117af9f7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6f7c28b3-3574-4d6d-91a8-4bead8722a2a",
   "metadata": {},
   "source": [
    "### 2.Explain the difference between a for loop and a while loop in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8f17022-5d75-41e7-9120-bf6ca5c91526",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "'''\n",
    "1. For loop, iterate over the iterables and check the condition and perform the statements inside the loop.\n",
    "2. while loop, first it check the condition and executes the statements inside the statement inside.\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b135d2bd-59e0-4522-b3a6-7839f5ffc2ad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cf20f981-2440-48df-a476-1923cc61a5bb",
   "metadata": {},
   "source": [
    "### 3.Write a Python program to calculate the sum of all numbers from 1 to 1000 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "68750361-19ee-4ce6-a33b-1f9bb299feee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all numbers from 1 to 100 : 5050\n"
     ]
    }
   ],
   "source": [
    "sum_of_all_numbers = 0\n",
    "for i in range(1, 101):\n",
    "    sum_of_all_numbers += i\n",
    "    \n",
    "print(f\"Sum of all numbers from 1 to 100 : {sum_of_all_numbers}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2c5685f-1c4d-40a8-8621-455a1ac276fe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f2c3b5b5-2106-42cf-bf70-77950a686736",
   "metadata": {},
   "source": [
    "### 4.How do you iterate through a list using a loop in python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "128f8ad3-62c7-43b2-8566-2a026f80b5db",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''1. in - in operator used to iterate over the list. for each iteration it takes each value in the list.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38383da1-d87d-4a5e-a787-7bc948a27138",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4b87b0ba-2342-4c78-bf87-bf769e924683",
   "metadata": {},
   "source": [
    "### 5. Write a Python program to find the product of all elemnts in a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "26ac8e60-a609-4384-b9a7-d93013219360",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of all elements in a list : 60\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_p = [1, 3, 4, 5]\n",
    "ele_p = 1\n",
    "for i in list_p :\n",
    "    ele_p *= i \n",
    "    \n",
    "print(f\"The product of all elements in a list : {ele_p}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44fdd41e-cfa7-4397-baf9-92fd6998d622",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4d3bde0a-b95f-4a6e-89a5-943bb932faa6",
   "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": 7,
   "id": "1f2d893c-25e2-4411-8bb0-e569859a23b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All even numbers from 1 to 20:\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(f\"All even numbers from 1 to 20:\")\n",
    "for i in range(1, 21):\n",
    "    if i%2 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dd7da58-4260-4d5b-9604-b65a1c1863d6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c0f367cd-dd73-4c69-b47f-f4533bdfc8ec",
   "metadata": {},
   "source": [
    "### 7.Write a Python program that calculates the factorial of a number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "885f1887-533c-4996-9db1-aa07a8c54ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter n value: 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of a 4 is : 24\n"
     ]
    }
   ],
   "source": [
    "\n",
    "fact = 1\n",
    "n = int(input(\"Enter n value:\"))\n",
    "for i in range(1, n+1):\n",
    "    if n == 0 or n == 1 :\n",
    "        break\n",
    "    else:\n",
    "        fact *= i\n",
    "\n",
    "print(f\"Factorial of a {n} is : {fact}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b582a1d-ecb8-4d99-9c06-8e77a0735fd0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "993f77ce-6dc6-452c-bf62-375d433e5604",
   "metadata": {},
   "source": [
    "### 8.How can you iterate through the characters of a string using a for loop in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e72472c2-a4ab-4776-a4e4-07846f10fef1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K\n",
      "o\n",
      "m\n",
      "a\n",
      "l\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Explanation : Initially, i takes character 'K' from string 'Komal' and print it. Then i will be incremented and i becomes next character which is 'o'. This process is repeated till last character of the string.\\n\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "'''1. we can iterate through the string using 'in' operator. If we use in operator in for loop, it takes each character for each iteration.\n",
    "'''\n",
    "string = \"Komal\"\n",
    "for i in string:\n",
    "    print(i)\n",
    "    \n",
    "    \n",
    "'''Explanation : Initially, i takes character 'K' from string 'Komal' and print it. Then i will be incremented and i becomes next character which is 'o'. This process is repeated till last character of the string.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cbd27e2-d496-41b9-99d5-098168aff979",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "eab3f224-d617-4cf0-8fea-1573529cffbb",
   "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": "83c62d7f-0be2-4b7f-8f6f-c8ac52dfc040",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "largest element in a list : 120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_9 = [10, 20, 2, 34, 120]\n",
    "large = list_9[0]\n",
    "for ele in list_9:\n",
    "    if ele > large:\n",
    "        large = ele \n",
    "        \n",
    "print(f\"largest element in a list : {large}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "123e529a-f1a0-4c93-9f97-922b2eef4cb5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a3985b08-b5ad-4bb6-8d63-34c0a7b43b4c",
   "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": 15,
   "id": "9e3d9069-3a04-43f7-9fe8-0a26160e148a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def fibonacci_Series(n : int) -> list:\n",
    "    l = []\n",
    "    if n <= 0:\n",
    "        return -1\n",
    "    if n == 1:\n",
    "        l.append(0)\n",
    "        return l\n",
    "    else:\n",
    "        l.extend([0, 1])\n",
    "        for i in range(1, n-1):\n",
    "            l.append(l[i] + l[i-1])\n",
    "    return l\n",
    "\n",
    "fibonacci_Series(10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "534cc058-27a5-477d-8451-d3ff24569388",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "66b04698-ec90-419a-86e4-63df5845d02f",
   "metadata": {},
   "source": [
    "### 11.Write a Python prgram to count the number of vowels in a given string using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ed53677b-9e97-4575-89e3-3069784a29a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of vowels in 'PythOn AssignMent is compeleted' : 9\n"
     ]
    }
   ],
   "source": [
    "\n",
    "vowel_count = 0\n",
    "string = \"PythOn AssignMent is compeleted\"\n",
    "\n",
    "for char in string :\n",
    "    if char in 'AEIOUaeiou' :\n",
    "        vowel_count += 1\n",
    "\n",
    "print(f\"Number of vowels in '{string}' : {vowel_count}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b830ce25-129a-4c3b-b532-f966e325ba24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1c117c57-d32f-4aed-a38e-302db61a3230",
   "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": 21,
   "id": "2faa1a24-b5e3-485d-89a6-9ef835b5b6ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter digit of the table : 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 * 1 = 8\n",
      "8 * 2 = 16\n",
      "8 * 3 = 24\n",
      "8 * 4 = 32\n",
      "8 * 5 = 40\n",
      "8 * 6 = 48\n",
      "8 * 7 = 56\n",
      "8 * 8 = 64\n",
      "8 * 9 = 72\n",
      "8 * 10 = 80\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = int(input(\"Enter digit of the table :\"))\n",
    "\n",
    "for i in range(1, 11):\n",
    "    print(f\"{n} * {i} = {n*i}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7ed11a2-c11a-478e-9112-4e09cae91ac5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "38a90e73-2346-4c44-b15e-369055d66f18",
   "metadata": {},
   "source": [
    "### 13. Write a Python program to reverse a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d9a00b86-9500-4109-a85c-fccee30b7f08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reverse  a list : [True, 'reverse', 20.7, 10, 'using']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_13 = ['using' , 10 , 20.7 , 'reverse' ,True ]\n",
    "for i in range(len(list_13) // 2):\n",
    "    list_13[i] , list_13[len(list_13) - i - 1] = list_13[len(list_13) - i - 1] , list_13[i]\n",
    "    \n",
    "print(f\"Reverse  a list : {list_13}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2204aad5-f43a-48c6-856a-fb44bddfe652",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c505b6f2-3a45-4375-99c8-9020933daefe",
   "metadata": {},
   "source": [
    "### 14.Write a Python program to find the common elements between two lists using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2848b727-31e8-4bc0-97f6-e4495811ec6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements between two lists : ['komal']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_a = ['komal']\n",
    "list_b = ['pw', 'skills', 'komal']\n",
    "\n",
    "list_common = []\n",
    "\n",
    "if len(list_b) < len(list_a):\n",
    "    for ele in list_b :\n",
    "        if ele in list_a :\n",
    "            list_common.append(ele)\n",
    "            \n",
    "else:\n",
    "    for ele in list_a:\n",
    "        if ele in list_b:\n",
    "            list_common.append(ele)\n",
    "            \n",
    "print(f\"Common elements between two lists : {list_common}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57c180f2-5a44-49d3-bf4b-acf8a7abb59c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c0c757a1-df14-4fb7-b975-54110cd2f69c",
   "metadata": {},
   "source": [
    "### 15.Explain how to use a for loop to iterate through the keys and values of a dictionary in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c62f6abc-4188-4187-a98c-94168ef9a045",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name = komal\n",
      "age = 28\n",
      "school = kvs\n",
      "Occupation = student\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Dictonary has mainly three method:\n",
    " 1. keys() - it gives the all the keys in dictionary\n",
    " 2. values() - it gives the all the values in dictionary\n",
    " 3. items() - it gives the all items in the dictionary\n",
    "\n",
    "we can iterate the dictionary using keys, values and items also.\n",
    "iterate using items()\n",
    "'''\n",
    "\n",
    "d = {'name' : 'komal', 'age' : 28 , 'school' : 'kvs' , 'Occupation' : 'student'}\n",
    "\n",
    "for k , v  in d.items():\n",
    "    print(f\"{k} = {v}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a1dd41b-6df5-4bc0-89a9-63bc8bc08c55",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d175ebfd-d7fa-4248-96f5-5f71226d4bcd",
   "metadata": {},
   "source": [
    "### 16.Write a Python program to find the GCD(Greatest common Divisor) of two numbers using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "695e6129-b2a8-4405-ad2d-32c2ea4df605",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def gcd(a : int, b : int) -> int :\n",
    "    while b != 0:\n",
    "        a, b = b, a%b\n",
    "        \n",
    "    return a\n",
    "\n",
    "def gcd_2(a : int , b : int):\n",
    "    if a < b:\n",
    "        for i in range(1, a+1):\n",
    "            if a % i == 0 and b % i  == 0 :\n",
    "                gcd = i\n",
    "                \n",
    "    return gcd\n",
    "\n",
    "gcd(16, 48)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c250eae7-d86a-45a7-bcd9-abf88f2cc355",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "112f5348-9d9f-4a5d-978e-500fb37adb0a",
   "metadata": {},
   "source": [
    "### 17.Create a Python program that checks if a string is a palindrome using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6a74bbbd-dc71-468b-a976-3679479184d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter a string: rad ar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string is palindrome\n"
     ]
    }
   ],
   "source": [
    "\n",
    "str17 = input(\"enter a string:\")\n",
    "str17_lower = (str17.replace(\" \", \"\")).lower()\n",
    "reverse_str = ''\n",
    "for i in range(len(str17_lower)-1 , -1, -1):\n",
    "    if str17_lower[i].isalnum():\n",
    "        reverse_str += str17_lower[i]\n",
    "        \n",
    "if reverse_str == str17_lower:\n",
    "    print(f\"string is palindrome\")\n",
    "else :\n",
    "    print(f\"string is not palindrome\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9dd0760-1c5b-4a24-bfae-98dd5bea1a0d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6494455a-d958-4563-aad9-6af6fe98e277",
   "metadata": {},
   "source": [
    "### 18.Write a Python program to remove duplicates from a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "86f0671d-db56-4f9b-b27c-656aa83ba460",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list after without duplicates : ['pw', 'python', 20, True]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list18 = ['pw' , 'python' , 20, 'pw', True]\n",
    "list_without_duplicates = []\n",
    "\n",
    "for element in list18:\n",
    "    if element not in list_without_duplicates:\n",
    "        list_without_duplicates.append(element)\n",
    "print(f\"list after without duplicates : {list_without_duplicates}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dfe92d6-5408-49a2-852c-2178fa9c290e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d0342184-cafe-4808-8226-d59a4144a35b",
   "metadata": {},
   "source": [
    "### 19.Create a Python program that counts the number of words in a sentence using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "716cf64c-7c90-43eb-b3e5-e7323c60daf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of words on sentence : 4\n"
     ]
    }
   ],
   "source": [
    "\n",
    "sentence = \"I love my india\"\n",
    "\n",
    "list_words = sentence.split()\n",
    "words_count = 0\n",
    "for word in list_words:\n",
    "    words_count +=1 \n",
    "    \n",
    "print(f\"Number of words on sentence : {words_count}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50e6b330-dc39-4058-aac1-75d28c0aec3c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "010a5d36-cfa2-4414-a8c8-c1d372b80628",
   "metadata": {},
   "source": [
    "### 20.Write a Python program to find the sum of all odd numbers from 1 to 50 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "759ee8d4-0b2e-4a2e-abb6-4b3ea6380aba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of odd numbers from 1 to 50 : 625\n"
     ]
    }
   ],
   "source": [
    "\n",
    "odd_sum = 0\n",
    "for i in range(1, 51):\n",
    "    if i % 2 != 0:\n",
    "        odd_sum += i \n",
    "        \n",
    "print(f\"Sum of odd numbers from 1 to 50 : {odd_sum}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d30f0e3-b96a-40f5-a624-87eda52a0378",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7fce483d-e786-4b4a-bc97-bf55b2bc1f6b",
   "metadata": {},
   "source": [
    "### 21.Write a Python program that checks if a given year is a leap year using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "02249a5e-48d3-49b2-a50a-2e8a626ed82b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "leap year list : [2000, 2004, 2400, 1200]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def check_leap(years : list) -> bool:\n",
    "    leap_year = []\n",
    "    for year in years :\n",
    "        if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:\n",
    "            leap_year .append(year)\n",
    "            \n",
    "    return leap_year\n",
    "\n",
    "leap_year_list = check_leap([2000, 2010, 2004, 2400, 1200])\n",
    "print(f\"leap year list : {leap_year_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d59423a-e732-47f1-8873-b36924016860",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1c7bd66f-dd3b-452d-a2d0-ad18215f1f53",
   "metadata": {},
   "source": [
    "### 22. Create a Python program that calculates the square root of a number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "31ba36d5-d6d4-4334-b69c-9cb367d25d97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def sq_root(num , iteration):\n",
    "    near_root = num / 2.0\n",
    "    for _ in range(iteration):\n",
    "        near_root = 0.5 * (near_root + (num/near_root))\n",
    "    return near_root\n",
    "\n",
    "sq_root(num = 25 , iteration = 100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "430e1603-3cee-48e2-a460-a12b9a2f93bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5250385c-12a2-429f-92bf-e292f3bc6377",
   "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": "4f36795d-a0ba-404a-ade6-93963f0e37e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter first number : 10\n",
      "Enter second number : 12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LCM of 10 and 12 is 60\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# LCM  - range of maximum and product of numbers \n",
    "\n",
    "first_number = int(input(\"Enter first number :\"))\n",
    "second_number = int(input(\"Enter second number :\"))\n",
    "\n",
    "max_of_two = max(first_number, second_number)\n",
    "\n",
    "def lcm(a , b):\n",
    "    for i in range(max_of_two, a*b+1):\n",
    "        if i % a == 0 and i % b == 0 :\n",
    "            return i \n",
    "        \n",
    "least_com_factor  = lcm(first_number , second_number)\n",
    "\n",
    "print(f\"LCM of {first_number} and {second_number} is {least_com_factor}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b54f3abf-0c41-4f97-9a4c-80fb895cc65d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "969379fc-2eaf-4dab-ab5c-71909992a0dd",
   "metadata": {},
   "source": [
    "### If else:\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c700c941-6e77-4e54-90c5-944228197638",
   "metadata": {},
   "source": [
    "### 1.Write a Python program to check if a number is positive, negative, or zero using an if-else statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b66ec914-b4dd-45df-a3fb-1d917bf08877",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number : -2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is negative\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = int(input(\"Enter a number :\"))\n",
    "\n",
    "if n>0:\n",
    "    print(\"Number is positive\")\n",
    "    \n",
    "elif n==0:\n",
    "    print(\"Number is zero\")\n",
    "\n",
    "else :\n",
    "    print(\"Number is negative\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "074990b4-8332-45da-a6d8-0e1d1623ba8f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b3152624-5f5c-419f-b3f0-1df0524e960b",
   "metadata": {},
   "source": [
    "### 2.Create a Python program that checks if a given number is even or odd using an if-else statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7b4aaaf6-170f-4ad7-8339-022fb866c942",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 27\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is odd\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = int(input(\"Enter a number\"))\n",
    "\n",
    "if n%2 == 0:\n",
    "    print(\"Number is even\")\n",
    "    \n",
    "else:\n",
    "    print(\"Number is odd\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "996d6238-10dc-4b94-9b37-d79ee7e17d16",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "36c34750-d9ee-43c2-b924-1ff983195834",
   "metadata": {},
   "source": [
    "### 3.How can you nested if-else statements in python, and provide an example?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "07a49ed8-5f33-45aa-97ee-e0edc118f3eb",
   "metadata": {},
   "source": [
    "1. Nested if-else means , the name it self stated that writing if conditions inside the if-else statements :\n",
    "### Example \n",
    "\n",
    "number = 0\n",
    "if number >= 0:\n",
    "    print(\"number is positive\")\n",
    "    if number == 0:\n",
    "        print(\"Number is greater but its zero\")\n",
    "else:\n",
    "    print(\"Number is negative\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f1db2695-6bd2-45d5-97e4-12c5ba528749",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number is positive\n"
     ]
    }
   ],
   "source": [
    "number = 25\n",
    "if number >= 0:\n",
    "    print(\"number is positive\")\n",
    "    if number == 0:\n",
    "        print(\"Number is greater but its zero\")\n",
    "else:\n",
    "    print(\"number is negative\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1fff2c-3b25-49b6-8102-0fa428daabdb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "33894ff8-9fb4-4894-8006-2e43a1624736",
   "metadata": {},
   "source": [
    "### 4.Write a Python program to determine the largest of three numbers using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3523a2aa-7821-4451-b1b0-8c8404ce621c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number : 12\n",
      "Enter the second number : 28\n",
      "Enter the third number : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest number is 28.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num1 = float(input(\"Enter the first number :\"))\n",
    "num2 = float(input(\"Enter the second number :\"))\n",
    "num3 = float(input(\"Enter the third number :\"))\n",
    "if num1 >= num2 and num1 >= num3 :\n",
    "    largest = num1\n",
    "elif num2 >= num1 and num2 >= num3 :\n",
    "    largest = num2\n",
    "else :\n",
    "    largest = num3\n",
    "    \n",
    "print(f\"The largest number is {largest}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97708577-0f20-44a6-9a6e-dfad6313ac4d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "911d023f-1dea-4475-8aba-349368d2f371",
   "metadata": {},
   "source": [
    "### 5.Write a python program that calculates the absolute value of a number using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3e6d5963-e6e0-4992-8506-1ef1999ea7cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number : -12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The absolute value of -12.0 is 12.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "number = float(input(\"Enter a number :\"))\n",
    "if number < 0:\n",
    "    absolute_value = -number\n",
    "else :\n",
    "    absolute_value = number\n",
    "print(f\"The absolute value of {number} is {absolute_value}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05bbccd2-9483-4a7a-913c-d5daef1f3459",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "495e9201-9d02-4dfc-87ad-342163bdb37f",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that checks if a given character is a vowel or consonant using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b42c00b6-0005-4296-b328-7c459861b86a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a single character  p\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p  is a consonant\n"
     ]
    }
   ],
   "source": [
    "\n",
    "char = input(\"Enter a single character \")\n",
    "if char in \"AEIOUaeiou\":\n",
    "    print(char, \" is a vowel\")\n",
    "else :\n",
    "    print(char, \" is a consonant\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfd5f8b7-3afe-41a2-bac7-7e148278ebd2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8fc9e2cb-5b88-4fb5-bbe0-057b44ebd6fe",
   "metadata": {},
   "source": [
    "### 7.Write a Python program to determine if a user is eligible to vote based on their age using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f98e7c19-83f1-4903-b0e4-71bb45e93239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age : 29\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you are eligible to vote\n"
     ]
    }
   ],
   "source": [
    "\n",
    "age = int(input(\"Enter your age :\"))\n",
    "\n",
    "if age >= 18:\n",
    "    print(f\"you are eligible to vote\")\n",
    "else :\n",
    "    print(f\"you are not eligible to vote\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "726bbbb4-09a6-4a29-a6dc-d91695b09f5f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "67e352f0-b552-4f40-89bd-8932c62471b1",
   "metadata": {},
   "source": [
    "### 8.Create a Python program that calculates the discount amount based on the purchase amount using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b85338d0-8744-42c9-846d-63dfa6278134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the purchase amount : 200\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " You get a 5% discount of $(discount : .2f)! \n",
      " Your final price after discount is 190.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "amount = float(input(\"Enter the purchase amount :\"))\n",
    "if amount > 1000:\n",
    "    discount = amount * 0.20\n",
    "    print(f\" You get a 20% discount of $(discount : .2f)!\")\n",
    "elif amount > 500 :\n",
    "    discount = amount * 0.10 \n",
    "    print(f\" You get a 10% discount of $(discount : .2f)!\")\n",
    "elif amount > 100 :\n",
    "    discount = amount * 0.05\n",
    "    print(f\" You get a 5% discount of $(discount : .2f)! \")\n",
    "else :\n",
    "    discount = 0 \n",
    "    print(f\" No discount for purchase below $100.\")\n",
    "\n",
    "final_price = amount - discount\n",
    "print(f\" Your final price after discount is {final_price}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78e1159d-f31a-40c9-8ab9-d6a1389e20d3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "626b5e21-05bc-4d10-a01f-79881b4200b3",
   "metadata": {},
   "source": [
    "### 9.Write a Python program to check if a number is within a specified range using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bb213ab9-40a3-45fc-af5c-dae076134b7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number : 22\n",
      "Enter the lower limit of the range : 1\n",
      "Enter the upper limit of the range : 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The number 22.0 is not within the range 1.0 to 2.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Get the number from the user\n",
    "number = float(input(\"Enter a number :\"))\n",
    "\n",
    "# Specify the range \n",
    "lower_limit = float(input(\"Enter the lower limit of the range :\"))\n",
    "upper_limit = float(input(\"Enter the upper limit of the range :\"))\n",
    "\n",
    "# Check if the number is within the range \n",
    "if lower_limit <= number <= upper_limit :\n",
    "    print(f\"The number {number} is within the range {lower_limit} to {upper_limit}\")\n",
    "else :\n",
    "    print(f\" The number {number} is not within the range {lower_limit} to {upper_limit}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7525853b-6e71-49eb-a678-eebc42eaac9f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b50fa019-fd52-4a56-99a3-5d695617bc36",
   "metadata": {},
   "source": [
    "### 10.Create a Python program that determines the grade of a student based on their score using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d0a25dcd-04fb-495b-b001-7de52e766223",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the student's score (0-100) : 89\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The student's grade is : B\n"
     ]
    }
   ],
   "source": [
    "\n",
    "score = float(input(\"Enter the student's score (0-100) :\"))\n",
    "if score >= 90 :\n",
    "    grade = 'A'\n",
    "elif score >= 80:\n",
    "    grade = 'B'\n",
    "elif score >= 70:\n",
    "    grade = 'C'\n",
    "elif score >= 60:\n",
    "    grade = 'D'\n",
    "elif score >=50:\n",
    "    grade = 'E'\n",
    "else :\n",
    "    grade = 'F'\n",
    "print(f\"The student's grade is : {grade}\")    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e68f72ed-5380-4c23-8d3e-9c70534b6ce6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "85987c14-8785-41a2-8c3a-2e91dd2b516f",
   "metadata": {},
   "source": [
    "### 11.Write a Python program to check if a string is empty or not using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "943245c6-d53d-456c-8250-8bd99fdea191",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : india\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string is not empty\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Get the string from the user\n",
    "user_string = input(\"Enter a string :\")\n",
    "\n",
    "#Check if the string is empty based on its length\n",
    "if len(user_string) == 0:\n",
    "    print(\"The string is empty\")\n",
    "else :\n",
    "    print(\"The string is not empty\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d512fb65-e87a-4c6f-988a-6598080be8e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "00bc88f9-08e9-4069-a621-89c37e52ff35",
   "metadata": {},
   "source": [
    "### 12.Create a Python that identifies the type of a triangle (e.g., equilateral, isosceles, or scalene) based on input values using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ea981bfe-793a-4291-9cc5-52de03ea6195",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isosceles\n"
     ]
    }
   ],
   "source": [
    "\n",
    "ang1 , ang2 , ang3 = 90, 45, 45\n",
    "if ang1 + ang2 + ang3  == 180:\n",
    "    if ang1 == ang2 and ang2 == ang3 :\n",
    "        print(f\"Equilateral\")\n",
    "    elif ang1 == ang2  or ang2 == ang3:\n",
    "        print(f\"isosceles\")\n",
    "    else :\n",
    "        print(f\"scalene\")\n",
    "else :\n",
    "    print(f\"sum of angles is < 180. so, it can't form a triangle\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "681bf8b6-bf09-4bcb-b168-8037b7f6cdc7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6c77833b-220c-42d2-bdb9-8df148ac4d04",
   "metadata": {},
   "source": [
    "### 13.Write a Python program to determine the day of the week based on a user-provided number using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9eb1e2ed-efeb-4f36-9e65-198ec4b1d630",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter day number : 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuesday\n"
     ]
    }
   ],
   "source": [
    "\n",
    "day_num = int(input(\"Enter day number :\"))\n",
    "if day_num == 1 :\n",
    "    print(f\"Monday\")\n",
    "elif day_num == 2 :\n",
    "    print(f\"Tuesday\")\n",
    "elif day_num == 3 :\n",
    "    print(f\"Wednesday\")\n",
    "elif day_num == 4 :\n",
    "    print(f\"Thursday\")\n",
    "elif day_num == 5 :\n",
    "    print(f\"Friday\")\n",
    "elif day_num == 6:\n",
    "    print(f\"Saturday\")\n",
    "else :\n",
    "    print(f\"Sunday\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b36bcdca-3513-457a-9da9-cf8e20588378",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f210ec34-9d80-4e8b-8a53-785c0f8a4acb",
   "metadata": {},
   "source": [
    "### 14.Create a Python program that checks if a given year is a leap year using both if-else and a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "93723e11-c591-40f4-8e88-9a9223743aab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year to check leap year : 2019\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019 is not leap year \n"
     ]
    }
   ],
   "source": [
    "\n",
    "year = int(input(\"Enter a year to check leap year :\"))\n",
    "\n",
    "if (year%4 == 0 and year%100 != 0 ) or (year%400 == 0):\n",
    "    print(f\"{year} is leap year \")\n",
    "else :\n",
    "    print(f\"{year} is not leap year \")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efb6b8c4-7e3b-48e9-949c-c534866526be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b7a663d8-894b-4e26-96ee-229b31025267",
   "metadata": {},
   "source": [
    "### 15.How do you use the \"assert\" statement in Python to add debugging checks within if-else blocks?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d07ed751-09b8-4e2d-bf28-24fc14aed376",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number between 1 to 10 : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is 5 or less \n"
     ]
    }
   ],
   "source": [
    "'''assert keyword os used for debugging purpose.\n",
    "This will validate condition and if false it raise an exception AssertionError\n",
    "'''\n",
    "\n",
    "x = int(input(\"Enter a number between 1 to 10 :\"))\n",
    "\n",
    "if x > 5 :\n",
    "    # Check that the number is indeed greater than 5\n",
    "    assert x > 5 , \"Number is not greater than 5 \"\n",
    "    print(\"The number is greater than 5 \")\n",
    "    \n",
    "else :\n",
    "    # Check that the number is 5 or less\n",
    "    assert x <= 5 , \"Number is greater than 5 \"\n",
    "    print(\"The number is 5 or less \")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91e2cdc2-c998-4a06-bba8-bf8d2c052362",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "87f99b93-4fca-4b5f-ad02-fd530f710661",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a09b9b3e-3978-4434-9f4a-23f0ea863487",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age : 78\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are eligible for senior citizen discount\n"
     ]
    }
   ],
   "source": [
    "\n",
    "age = int(input(\"Enter your age :\"))\n",
    "senior_citizen = 60\n",
    "if age >= senior_citizen:\n",
    "    print(f\"You are eligible for senior citizen discount\")\n",
    "else :\n",
    "    print(f\"You are not eligible for senior citizen discount\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f0279f-af24-4a97-8928-38722e91357c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "432d15fe-e846-4a94-9d9d-3261b021dc14",
   "metadata": {},
   "source": [
    "### 17.Write a Python program to categorize a given character as uppercase, lowercase, or neither using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b63eabd2-a2b4-4691-997c-0cf65837ada7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a single character : P\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character 'P' is an uppercase letter\n"
     ]
    }
   ],
   "source": [
    "\n",
    "char = input(\"Enter a single character :\")\n",
    "if char.isupper():\n",
    "    print(f\"The character '{char}' is an uppercase letter\")\n",
    "elif char.islower():\n",
    "    print(f\"The character '{char}' is a lowercase letter\")\n",
    "else :\n",
    "    print(f\"The character '{char}' is a neither.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bb0b691-bccb-4148-b51f-3b7b1b18aa89",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "39045417-4e42-4171-94f0-7bcf8bfef81a",
   "metadata": {},
   "source": [
    "### 18.Write a Python program to determine the roots of a quadratic equation using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "44ea48aa-2ef8-4472-ab0c-e0301588347b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the coefficient of a : 1\n",
      "Enter the coefficient of b : 6\n",
      "Enter the coefficient of c : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Two distinct real roots : root1 : -0.5505102572168221 and root2 : -5.449489742783178\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# ax^2 + bx + c = 0\n",
    "from math import sqrt\n",
    "a = float(input(\"Enter the coefficient of a :\"))\n",
    "b = float(input(\"Enter the coefficient of b :\"))\n",
    "c = float(input(\"Enter the coefficient of c :\"))\n",
    "\n",
    "discriminant = b**2 - 4*a*c\n",
    "\n",
    "#Determine the nature of roots and calculate them \n",
    "if discriminant > 0:\n",
    "    d = sqrt(discriminant)\n",
    "    root1, root2 = (-b + d) / 2*a , (-b - d) / 2*a\n",
    "    print(f\"Two distinct real roots : root1 : {root1} and root2 : {root2}\")\n",
    "\n",
    "elif discriminant == 0:\n",
    "    root = -b / (2*a)\n",
    "    print(f\"One real root : {root}\")\n",
    "    \n",
    "else :\n",
    "    print(\"The roots are complex (not real)\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6442540-040b-4ffd-a1b4-a154cf23690c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "09b55fa9-6198-46c2-afee-21519ed70657",
   "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": 4,
   "id": "87e96a46-9fb3-4d0c-97ad-a7a633874846",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year : 2000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000 is a century year\n"
     ]
    }
   ],
   "source": [
    "\n",
    "year = int(input(\"Enter a year :\"))\n",
    "if year % 100  == 0 :\n",
    "    print(f\"{year} is a century year\")\n",
    "else :\n",
    "    print(f\"{year} is not a century year\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0c096de-2001-457e-975a-cfb234926151",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7eb43edd-1e40-4ad6-ac3d-8db61729d7b9",
   "metadata": {},
   "source": [
    "### 20.Write a Python program to determine if a given number is a perfect square using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "040ea196-2c0c-4250-a9b2-b37c8a465be6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number : 36\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 is a perfect square\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = int(input(\"Enter a number :\"))\n",
    "sqrt = num**0.5\n",
    "if round(sqrt)**2  == num :\n",
    "    print(f\"{num} is a perfect square\")\n",
    "else :\n",
    "    print(f\"{num} is not a perfect square\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "673e6806-6d5e-441e-b12b-f3244dd3381c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "210b635f-ecef-409e-9881-23233977fe6d",
   "metadata": {},
   "source": [
    "### 21.Explain the purpose of the \"continue\" and \"break\" statements within if-else loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2db108ac-5358-477e-889b-cd6a770e1003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "\n",
      "\n",
      "0\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "break  is used to exit a loop completely.\n",
    "continue is used to skip the current iteration and proceed to the next one.\\\n",
    "when a break statement is encountered inside a loop,\n",
    "the loop terminates immmediately, and program control proceeds to the next statement following the loop.\n",
    "'''\n",
    "\n",
    "for i in range(5):\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(i) # In the above code, the breaks when i equals 3, so numbers after 2 are not printed.\n",
    "    \n",
    "\n",
    "'''\n",
    "when a continue statement is encountered inside a loop,\n",
    "the currrent iteration of the loop is terminated immediately, and the loop's next iteration begins.\n",
    "'''\n",
    "print(\"\\n\")\n",
    "for i in range(5):\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i) # In the above code, when i equals 3, the print(i) statement is skipped due to the continue statement, but the loop continues with the next iteration.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35e42869-12db-47c3-8d77-12a0efce34d5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c980601d-24df-4d10-a4f2-999b6fc50804",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "26134411-daf9-47ae-b1ad-04bfefcb5c97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your weight in kilograms : 70\n",
      "Enter your height in meters : 1.21\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your BMI is  47.81. You are classified as obesity.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "weight = float(input(\"Enter your weight in kilograms :\"))\n",
    "height = float(input(\"Enter your height in meters :\"))\n",
    "bmi = weight / (height**2)\n",
    "\n",
    "if bmi < 18.5 :\n",
    "    print(f\"Your BMI is {bmi : .2f}. You are classified as underweight.\")\n",
    "elif 18.5 <= bmi < 25 :\n",
    "    print(f\"Your BMI is {bmi : .2f}. You are classified as Normal weight.\")\n",
    "elif 25 <= bmi < 30 :\n",
    "    print(f\"Your BMI is {bmi : .2f}. You are classified as overweight.\")\n",
    "else :\n",
    "    print(f\"Your BMI is {bmi : .2f}. You are classified as obesity.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baee5a05-4b71-4e7d-9580-60c321ba464a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "55f376ea-a87f-4d91-a193-d6687d0ec3b8",
   "metadata": {},
   "source": [
    "### 23.How can you use the \"filter()\" function with if-else statements to filter elements from a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "aed9f548-aaec-40b6-bdb2-ede6c2030ac9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 18, 50, 100]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "filter() is inbuilt function, which used to filter the data by passing function with data.\n",
    "When the function condition is true it will filter the data.\n",
    "\n",
    "General systax : filter(function, data)\n",
    "\n",
    "Example:\n",
    "'''\n",
    "def check_even(num : list):\n",
    "    if num % 2 == 0:\n",
    "        return True\n",
    "    \n",
    "data = [0, 23, 11 ,18 , 50, 100]\n",
    "list(filter(check_even, data))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "957b1dc0-c76a-449c-a321-4e76fbcccf3a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "32b93d5c-89e0-4318-9437-8a87981bf6f7",
   "metadata": {},
   "source": [
    "### 24.Write a Python program to determine if a given number is prime or not using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9ccb2a8f-dd72-402e-8a70-ab2396f910e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number : 12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 is not a prime number\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = int(input(\"Enter the number :\"))\n",
    "if num < 2 :\n",
    "    print(f\"{num} is not a prime number\")\n",
    "else :\n",
    "    is_prime = True \n",
    "    for i in range(2, num):\n",
    "        if num % i == 0:\n",
    "            is_prime = False \n",
    "            break\n",
    "    if is_prime:\n",
    "        print(f\"{num} is a prime number\")\n",
    "    else :\n",
    "        print(f\"{num} is not a prime number\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "340a4533-a1f9-4d33-8d89-19e6b56a342c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "55f7d654-abae-445f-9e45-fdfe6a447f63",
   "metadata": {},
   "source": [
    "### Map :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b61c7e01-5515-41bb-b62e-2867a92d1abd",
   "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."
   ]
  },
  {
   "cell_type": "raw",
   "id": "078a55da-26be-4130-99c8-951836a4e13a",
   "metadata": {},
   "source": [
    "\n",
    "'''\n",
    "map() - This is inbuilt function which is used to apply the some functionality over the any iterables.\n",
    "\n",
    "General syntax : map(function, iterables)\n",
    "\n",
    "Explanation: map function takes arguments as one function and iterables. Then it will apply the functionality on the each and every element in the iterables.\n",
    "\n",
    "Example : add some k value to every element in the list\n",
    "'''\n",
    "\n",
    "l = [0, 1, 2, 3, 4, 5]\n",
    "k = 5\n",
    "list(map(lambda x : x+k , l))\n",
    "\n",
    "'''\n",
    "Explanation : \n",
    "l is a list of elements. In the first iteration, it takes the first element from list l and perform the lambda operation (adding 5). Repeat the same process\n",
    "for all the elements in the list l.\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7ed84759-7601-4b43-95a5-d717d85131c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [0, 1, 2, 3, 4, 5]\n",
    "k = 5\n",
    "list(map(lambda x : x+k , l))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "648aff5c-3771-4b8b-966b-76a309e8df15",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "383bd729-39e0-4766-8e1c-dc8578c542c1",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the 'map()' function to square each element of a list of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3d2d11d6-7357-4f36-ba97-6bb4faf3bc01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of list of elements : [0, 1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def square(x):\n",
    "    return x**2 \n",
    "    \n",
    "number_list = [0,1,2,3,4,5]\n",
    "square_list = list(map(square, number_list))\n",
    "\n",
    "print(f\"Square of list of elements : {square_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "445b4906-fa47-443e-8781-aad692c10340",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "03a235e0-88b9-4082-9d71-0ca2a868651f",
   "metadata": {},
   "source": [
    "### 3.How does the 'map()' function differ from a list comprehension in Python, and when would you choose one over the other?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a6831f09-9d00-4a32-8a76-f2576e20a560",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using map() to print square of even numbers:\n",
      "[4, 16, 36]\n",
      "\n",
      "Using list comprehension to print square of even numbers:\n",
      "[4, 16, 36]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "The map() function and list comprehension are both tools in python for generating lists through some form of transformation or filtering.\n",
    "However, they have different syntactical and functional characteristics.\n",
    "'''\n",
    "\n",
    "#Certainly! Let's consider a simple example where we want to square all even numbers from a given list.\n",
    "\n",
    "#Using map():\n",
    "numbers = [1,2,3,4,5,6,7]\n",
    "squared_evens_map = map(lambda x : x**2 , filter(lambda x : x%2 == 0, numbers))\n",
    "print(f\"Using map() to print square of even numbers:\")\n",
    "print(list(squared_evens_map))\n",
    "\n",
    "#Using list comprehension \n",
    "squared_even_list_comp = [x**2 for x in numbers if x%2 == 0]\n",
    "print(\"\\nUsing list comprehension to print square of even numbers:\")\n",
    "print(squared_even_list_comp)  #output: [4, 16, 36]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6acd0a88-63dc-43c9-b464-4b7345025af5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7933837d-1ee8-4d55-bb12-70fe1714c5a3",
   "metadata": {},
   "source": [
    "### 4.Create a Python program that uses the 'map()' function to convert a list of names to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f36770a8-2e0c-432c-a4d6-c9d076cc0cc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list of names to uppercase : ['PYTHON', 'LANGUAGE']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "names_list = ['python', 'language']\n",
    "names_upper = list(map(lambda x : x.upper() , names_list))\n",
    "print(f\"list of names to uppercase : {names_upper}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64928cd9-a459-4ced-a991-a1b9ba7db32f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "217cb97e-8b3f-4bab-8870-769bcc8f9d51",
   "metadata": {},
   "source": [
    "### 5.Write a Python program that uses the 'map()' function to calculate the length of each word in a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "40a18d52-535f-4487-9d76-459651c9f24b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list of strings length : [2, 7, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "strings_list = ['pw', 'program', 'is' ,'Good']\n",
    "strings_length = list(map(lambda l : len(l), strings_list))\n",
    "print(f\"list of strings length : {strings_length}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aad94d8-2cb6-4700-a948-f1be903e2fb9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7c9288b5-9122-42d6-8865-6c8242b75f8d",
   "metadata": {},
   "source": [
    "### 6.How can you use the 'map()' function to apply a custom to elements of multiple lists simulataneously in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1d2a6625-127e-4aaf-86ee-0674c4793e48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultant list : [5, 7, 10]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "map(func, list1 , list2)\n",
    "If see above syntax, there is custom function func which can be applied to the different lists(list1 , list2). maps the functions to the \n",
    "corresponding values of the each list.\n",
    "\n",
    "Example :\n",
    "'''\n",
    "def add_func(list1, list2):\n",
    "    return list1 + list2\n",
    "\n",
    "list1 = [1,2,4]\n",
    "list2 = [4,5,6]\n",
    "result_list = list(map(add_func, list1, list2))\n",
    "print(f\"Resultant list : {result_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a80ffb13-2e7d-4c1a-b3e7-45bf8fcc66ac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7bbdab03-e246-4124-af53-30cb6890c88f",
   "metadata": {},
   "source": [
    "### 7.Create a Python program that uses 'map()' to convert a list of temperatures from Celsius to Fahrenheit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f46c73b0-ed75-4b9b-a998-9c77ca51accd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperature in fareheneit : [50.0, 68.0, 32.0, 122.0]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def cel_farenheit(celsius):\n",
    "    farenheit = (celsius * (9/5)) + 32\n",
    "    return farenheit\n",
    "\n",
    "c_temp = [10, 20, 0, 50]\n",
    "f_temp = list(map(cel_farenheit, c_temp))\n",
    "print(f\"Temperature in fareheneit : {f_temp}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "650230dc-a289-45e1-a00d-4e4f405f904c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4dfda704-efc8-4699-8dc7-4415328a5d99",
   "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 integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "18d63ee3-7d88-44f4-8fbd-69db5d639f35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list : [2.3, 4.6, 9.8, 5.5]\n",
      "New list : [2, 5, 10, 6]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "float_numbers = [2.3, 4.6, 9.8, 5.5]\n",
    "rounded_number = map(round , float_numbers)\n",
    "print(f\"Old list : {float_numbers}\")\n",
    "print(f\"New list : {list(rounded_number)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2490dac6-56e7-475b-83d2-60d203d483ce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60f00f77-e2fb-4f20-be3e-f42cf29381b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "238e5ac2-95ca-4fd0-8355-5f6ba65b567b",
   "metadata": {},
   "source": [
    "### Reduce :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5c6c1fd-7751-4628-93d9-05804488cc84",
   "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": 36,
   "id": "bdfdeff7-f996-40d4-aaf1-989da7205cab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reduced the result : 120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "The reduce() function is a part of python's functools module.\n",
    "It's used to apply a particular function passed in its argument to all the list elements mentioned in the sequence passed along.\n",
    "Essentially, it continually applies a function to the elements of a sequence, reducing the sequence to a single value.\n",
    "'''\n",
    "from functools import reduce\n",
    "numbers = [1,2,3,4,5]\n",
    "result = reduce((lambda x, y : x*y) , numbers)\n",
    "print(f\"Reduced the result : {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37bad498-ff3b-46ee-b8fa-1879df9bd403",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "65a15f92-c2b7-4fa0-bd61-1927f0b86adf",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the 'reduce()' function to find the product of all elements in a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "39d3490e-19dd-4211-8770-698d7724ac05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product of all elements in a list : 120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "l = [2,3,4,5]\n",
    "product_list = reduce((lambda x , y : x*y), l)\n",
    "print(f\"Product of all elements in a list : {product_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b3f8065-225f-4406-bb21-658e280e095f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "57be3e65-57cf-4cab-b07d-49f6c0264143",
   "metadata": {},
   "source": [
    "### 3.Create a Python program that uses 'reduce()' to find the maximum element in a list of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "302e9aa9-4824-4f91-b50f-4913e53f98bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum element in a list of numbers : 28\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_number = [23, 6, 13, 0, 28, 11]\n",
    "max_element = reduce((lambda a, b : a if a>b else b), list_number)\n",
    "print(f\"Maximum element in a list of numbers : {max_element}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7c6d7a2-7a4d-4296-b938-20ffd8fb4dc3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c61b63e5-2290-4f39-b818-379607d32a1c",
   "metadata": {},
   "source": [
    "### 4.How can you use the 'reduce()' function to concatenate a list of strings into a singe string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "11a38f63-d62a-4bc7-93f3-1f39282688ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single string : Komal is good girl.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from functools import reduce\n",
    "l4 = ['Komal' , 'is' , 'good' , 'girl.']\n",
    "single_string = reduce(lambda a , b : a+ \" \" +b, l4)\n",
    "print(f\"Single string : {single_string}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6ef9b14-9fb7-49a1-ae8d-c9b9038746cc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d606a3b4-b3c3-40a7-92a1-9441e4a52750",
   "metadata": {},
   "source": [
    "### 5.Write a Python program that calculates the factorial of a number using the 'reduce()' function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6901bccc-2630-4947-a80b-314436b3c1ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of 6 is : 720\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = 6\n",
    "fact = reduce(lambda x, y : x*y , range(1, n+1))\n",
    "print(f\"Factorial of {n} is : {fact}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ace9856b-25b7-4d42-aa53-89daeb23e52b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9a874bc7-05b2-46e7-9f36-4ce4f38655c7",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that uses 'reduce()' to find the GCD (Greatest Common Divisor) of a list of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8c4585fd-f94a-4966-b308-243c9b283ea8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of a list of numbers : 3\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from functools import reduce\n",
    "import math\n",
    "number = [24, 60, 15]\n",
    "result = reduce(math.gcd, number)\n",
    "print(f\"GCD of a list of numbers : {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b31a9c7-cdcb-4b1c-8693-564523523af2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "71cf00f3-981d-4e79-a586-96f1703afd15",
   "metadata": {},
   "source": [
    "### 7.Write a Python program that uses the 'reduce()' function to find the sum of the digits of a given number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6e01cbf5-2045-4b38-a86d-45cd23e483b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the digits of a given number : 19\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from functools import reduce\n",
    "num = 23545\n",
    "digits = [int(digit) for digit in str(num)]\n",
    "sum_of_digit  = reduce(lambda x , y : x+y ,digits)\n",
    "print(f\"Sum of the digits of a given number : {sum_of_digit}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57d08e13-3914-4476-85cb-881ea4a77ce9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a4c9dae4-2156-419b-bd25-d5df5760162c",
   "metadata": {},
   "source": [
    "### Filter :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7527931-96e2-4ba7-8e61-b04b5b1f0f9f",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "770af219-3932-40b7-8142-48d85b9d3e1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filter even number from list : [2, 4]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "The filter() function in python is used to filter the elements of an iterable based on a function that tests each element in the iterable\n",
    "to be true or not. The function returns an iterator from the elements of the iterable for which the function returns true.\n",
    "\n",
    "In simpler terms, filter(function, iterable) will return all items from the iterable for which the function returns true.\n",
    "\n",
    "Example :\n",
    "\n",
    "let's say you have a list of numbers and you want to filter out only the even numbers.\n",
    "'''\n",
    "number = [1,2,3,4,5]\n",
    "def even_num(n):\n",
    "    return n % 2 == 0\n",
    "\n",
    "even_number = filter(even_num ,number)\n",
    "print(f\"Filter even number from list : {list(even_number)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e64fffec-4661-4a2e-993c-f4b42fd1fa81",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "37710e5b-b5d0-4739-84e9-38e73c35063b",
   "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": 4,
   "id": "f007abba-5084-410f-9228-38d2bb6ba10d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using filter() to select even numbers from a list of integers : [2, 4, 56]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = [1,2,3,4,5,56,73]\n",
    "even_number = filter(lambda x : x % 2 == 0 , n)\n",
    "print(f\"Using filter() to select even numbers from a list of integers : {list(even_number)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f65a68d-0a39-4265-8d62-df08073cedf3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "83eb4da1-dc48-4acc-8ee9-44a14d4f6977",
   "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": 5,
   "id": "ba090537-e3bb-4ba8-b8eb-537b0f3829ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['add', 'all', 'at']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_3 = ['add' , 'all', 'python' , 'select' , 'at']\n",
    "select_name = filter(lambda x : x[0] == 'a' , list_3)\n",
    "print(list(select_name))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e94e9edf-2f87-4d2d-bbaf-d3a4b0b01557",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5f9bf1e1-22a0-4191-9796-56ad30abdf1e",
   "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": 9,
   "id": "1801ecdb-b914-440a-9fec-0e2e029fc58b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 11]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_4 = [1,2,4,3,5,6,65,11,88]\n",
    "prime_numbers  = filter(lambda n : n>1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1)), list_4)\n",
    "print(list(prime_numbers))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "834dc982-01c4-453c-99ef-32fd546c367d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "34ab6465-cce7-4040-a833-40e99edea1cc",
   "metadata": {},
   "source": [
    "### 5.How can you use the 'filter()' function to remove None values from a list in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4fc055e6-dd97-40e7-b8b0-28bec8bbc0c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List without none values : [1, 2, 4, 6, 76, 'str']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_5 = [1, None, 2,4,6,76,'str']\n",
    "remove_none_value = list(filter(lambda x : x != None , list_5))\n",
    "print(f\"List without none values : {remove_none_value}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8867d2c6-4e00-4c62-858e-2dd630b8f0fb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b0f9bb3b-4ebc-47b0-82fa-77004a51f33d",
   "metadata": {},
   "source": [
    "### 6.Create a Python program that uses 'filter()' to select words longer than a certain length from a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "50fab053-d10d-439a-a372-08e6a2b564c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['filter', 'function', 'python']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_6 = ['that', 'use', 'filter','function', 'in' ,'python']\n",
    "select_word_len = list(filter(lambda x : len(x)>5 , list_6))\n",
    "print(select_word_len)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03298dd3-9ff1-42d3-b9e8-9ebd394861d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c44ee5fb-4989-41f4-87c2-94b84fccca66",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f70503c7-45d3-4121-933c-77908e823d31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 34]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_7 = [10, 23 ,20, 50, 12 , 34]\n",
    "threshold = 23\n",
    "greater_value = list(filter(lambda x : x>threshold , list_7))\n",
    "print(greater_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c61647fe-af4a-4cc8-ad36-78f22ee2b2a2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9ff62682-ac0c-4d29-8e55-e2e8760658df",
   "metadata": {},
   "source": [
    "### Recursion :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ccd5f7c-c557-48c5-87da-f9ae24e15173",
   "metadata": {},
   "source": [
    "### 1.Explain the concept of recursion in Python. How does it differ from iteration?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "20bdc6f6-3dd4-46ea-a5bd-f2849a984a06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5040\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "recursion is a programming technique where a function calls itself, either directly or indirectly, in order to solve a larger problem by \n",
    "breaking it down into smaller, more manageable sub-problems.\n",
    "It's often used for tasks that can be defined in terms of similar, simpler sub-tasks, like the classic examples of computing\n",
    "factorials  or Fibonacci numbers.\n",
    "'''\n",
    "def fact_recursive(n):\n",
    "    if n == 0:\n",
    "        return 1 \n",
    "    else :\n",
    "        return n * fact_recursive( n - 1)\n",
    "print(fact_recursive(7))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94c5acc3-68f0-436e-97a1-e4400b8b983a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "903c92cf-d068-4a2e-a8ec-fdda78be9dd0",
   "metadata": {},
   "source": [
    "### 2.Write a Python program to calculate the factorial of a number using recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7ff8f10f-e8ef-4f10-9a6c-4d0361db2823",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def fact_recursive(n):\n",
    "    if n == 0 :\n",
    "        return 1 \n",
    "    else :\n",
    "        return n * fact_recursive( n - 1)\n",
    "    \n",
    "print(fact_recursive(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4255aea-4100-49bb-91f2-d0d5c1ffaf10",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a5da55d9-976d-4ef2-a4fd-abe736bfbc3f",
   "metadata": {},
   "source": [
    "### 3.Create a recursive Python function to find the nth Fibonacci number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c81f98b3-ea28-4fe7-88d1-3f57e26944da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def fib(n):\n",
    "    if n <= 0:\n",
    "        return 0\n",
    "    elif n == 1 :\n",
    "        return 1\n",
    "    else :\n",
    "        return fib(n-2) + fib(n-1)\n",
    "    \n",
    "fib(7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae9d0eb6-863b-4c38-b425-14f94f335ab5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ebfe370b-7047-43d6-ae58-f702fddd99c2",
   "metadata": {},
   "source": [
    "### 4.Write a recursive Python Function to calculate the sum of all elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e2ddb9ea-3308-4f75-8aec-465d16872ec8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the list : 28\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def recursive_sum(l):\n",
    "    if not l :\n",
    "        return 0 \n",
    "    return l[0] + recursive_sum(l[1:])\n",
    "\n",
    "# Test the function \n",
    "numbers = [1,2,3,4,5,6,7]\n",
    "print(f\"Sum of the list : {recursive_sum(numbers)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a592521a-7057-43a4-b811-d4e0ba78f09c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "64dbe01a-13ce-4b22-a168-12f3eebcd3fe",
   "metadata": {},
   "source": [
    "### 5. How can you prevent a recursive function from running indefinitely, causing a stack overflow error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ee720091-ac7a-45f1-8c05-a7bdafb518f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "Its important to write the base form for the recursion, otherwise there will be chance that recursion running forever.\n",
    "'''\n",
    "def fibonacci(n):\n",
    "    if n <= 1 :\n",
    "        return n \n",
    "    return fibonacci(n-2) + fibonacci(n-1)\n",
    "\n",
    "fibonacci(7) \n",
    "# For fibonacci(7), this function would make multiple redundant calls, which makes it highly inefficient for larger n.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2cc58e6-8038-4e93-8b38-6ed91adfa876",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f1045e1e-79ca-4fc0-ae7e-300063639e08",
   "metadata": {},
   "source": [
    "### 6.Create a recursive Python function to find the greatest common divisor (GCD) of two numbers using the Euclidean algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8d53a23e-ccc4-4e39-a8c9-0b429fe111b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of 12 and 48 is : 12 \n"
     ]
    }
   ],
   "source": [
    "\n",
    "def gcd(n1 , n2):\n",
    "    if n2 == 0:\n",
    "        return n1\n",
    "    return gcd(n2, n1%n2)\n",
    "\n",
    "a = 12\n",
    "b = 48\n",
    "print(f\"GCD of {a} and {b} is : {gcd(a, b)} \")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "510f7dd3-a1ce-4f58-9c2b-e29a7d880f28",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b58858c4-9d23-438a-8ab3-60e2779facef",
   "metadata": {},
   "source": [
    "### 7.Write a recursive Python function to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "23c09800-76e5-4973-a2a8-9bcce70e244a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string : Write a program\n",
      "Reversed string : margorp a etirW\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def reverse_string(str):\n",
    "    if str == '':\n",
    "        return ''\n",
    "    else :\n",
    "        return reverse_string(str[1:]) + str[0]\n",
    "\n",
    "string = \"Write a program\"\n",
    "print(f\"Original string : {string}\")\n",
    "print(f\"Reversed string : {reverse_string(string)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb2e87d-ca1b-46e6-95b0-095b65ee3c24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9210741f-be91-4d68-b28b-92aab69ac517",
   "metadata": {},
   "source": [
    "### 8.Create a recursive Python function to calculate the power of a number(x^n)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "482c801b-d142-47bb-8609-62aade260708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 raised to the power 5 is : 243\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def power(x, n):\n",
    "    if n == 0 :\n",
    "        return 1 \n",
    "    else :\n",
    "        return x*power(x, n-1)\n",
    "a = 3\n",
    "b = 5\n",
    "value = power(a, b)\n",
    "print(f\"{a} raised to the power {b} is : {value}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b879052c-c72d-4377-bf17-7f0724b4eda1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9bbe025f-b6c3-45fc-9c13-37bb81b8156d",
   "metadata": {},
   "source": [
    "### 9.Write a recursive Python function to find all permutations of a given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4d34ba94-4ab8-4538-8e6a-49e0f287e3c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Permutations of abc are :\n",
      "['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def get_permutations(s):\n",
    "    if len(s) <= 1:\n",
    "        return [s]\n",
    "    permutations = []\n",
    "    for i in range(len(s)):\n",
    "        current_char = s[i]\n",
    "        remaining_chars = s[:i] + s[i+1:]\n",
    "        for p in get_permutations(remaining_chars):\n",
    "            permutations.append(current_char + p)\n",
    "            \n",
    "    return permutations\n",
    "\n",
    "string = \"abc\"\n",
    "print(f\"Permutations of {string} are :\")\n",
    "print(get_permutations(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "057b9944-58bf-4fa0-b870-afe7dc9c803c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "60554a1c-9ba2-4d33-831b-7f11ae5997e0",
   "metadata": {},
   "source": [
    "### 10.Write a recursive Python function to check if a string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a4ed5110-6037-475d-8d26-a86f739a41ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 'radar' is a palindrome\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def is_palindrome(s):\n",
    "    if len(s) <= 1 :\n",
    "        return True\n",
    "    if s[0] != s[-1] :\n",
    "        return False\n",
    "    return is_palindrome(s[1:-1])\n",
    "test_string = \"radar\"\n",
    "if is_palindrome(test_string):\n",
    "    print(f\" '{test_string}' is a palindrome\")\n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3ef8636-9c92-4027-943e-786e598135fc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2204a827-0433-44d7-9e3a-d382871a7338",
   "metadata": {},
   "source": [
    "### 11.Create a recursive Python function to generate all possible combinations of a list of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "72082ae8-baf6-4e06-b9a9-24f3ac6774a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combinations of [1, 2, 3] are:\n",
      "[[], [3], [2], [3, 2], [1], [3, 1], [2, 1], [3, 2, 1]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def combinations(lst):\n",
    "    if not lst:\n",
    "        return [[]]\n",
    "    first_elem = lst[0]\n",
    "    sub_combinations = combinations(lst[1:])\n",
    "    next_combinations = [comb + [first_elem] for comb in sub_combinations]\n",
    "    \n",
    "    return sub_combinations + next_combinations\n",
    "elements = [1, 2, 3]\n",
    "print(f\"Combinations of {elements} are:\")\n",
    "print(combinations(elements))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31159308-5e9b-43a5-8854-5c0af2ae46c1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "399ed943-e291-44a5-bfa5-1f0eb981348e",
   "metadata": {},
   "source": [
    "### Basics of Functions :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13526902-b475-4fad-8e3a-6c897a0dc464",
   "metadata": {},
   "source": [
    "### 1.What iis a function in Python, and why is it used?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7a415da-9a08-45eb-aa48-c81b6e34e8ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "'''\n",
    "A function in python is a block of organized, reusable code that \n",
    "performs a specific task or set of tasks.\n",
    "Functions help in breaking down larger programs into smaller,\n",
    "modular chunks, making them easier to manage, debug, and understand.\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f18d04fa-be7a-4e2e-bc1c-72bc0c6c4d13",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "45490ffd-eb30-4c6a-9ed0-81b0cb86c392",
   "metadata": {},
   "source": [
    "### 2.How do you define a function in Python? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4d97c40d-fe6c-43a0-b020-ebc6b63cd285",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function in python!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "function is always defined with 'def' keyword followed by the name \n",
    "of the function along with list of arguments in the parenthesis.\n",
    "arguments is optional we can pass based on our requirement.\n",
    "\n",
    "General syntax : def name_if_function(arguments):\n",
    "'''\n",
    "def greet():\n",
    "    print(\"function in python!\")\n",
    "    \n",
    "greet()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b511561-eb70-44f7-a70c-67c6056faa6f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "68a63039-47a9-4997-b632-c7fdbfc6581e",
   "metadata": {},
   "source": [
    "### 3.Explain the difference between a function definition and a function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4389a527-d139-4784-b1a7-43b84314c105",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "function definition : used to write the block of the code.\n",
    "function call: used to execute the block of the code which is defined in function definition.\n",
    "'''\n",
    "def add(a, b):\n",
    "    return a+b\n",
    "\n",
    "sum_result = add(2,6)\n",
    "print(sum_result)  #output : 8\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e791aa21-a970-4fe4-944d-e1e6761d6f97",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24b1f924-e5c3-4041-b265-926610812ead",
   "metadata": {},
   "source": [
    "### 4.Write a Python program that defines a function to calculate the sum of two numbers and then calls the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fd85141f-ca4f-4a58-8516-f055bc07ca70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of two numbers : 22\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def add_num(a, b):\n",
    "    return a+b\n",
    "\n",
    "sum_of_two_num = add_num(12,10)\n",
    "print(f\"The sum of two numbers : {sum_of_two_num}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2838b5a1-b1eb-44e6-9da1-c5ae9ef5d5cc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f1c94d0e-09ec-455b-8ea5-41f93276575e",
   "metadata": {},
   "source": [
    "### 5.What is a function signature, and what information does it typically include?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d6e47be0-ce86-4261-be49-b195f4207e2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "A function signature defines the interface through which a function can be called.\n",
    "It provides essential details about the function, \n",
    "allowing users (and tools like type checkers or IDEs) to understand how to invoke the function correctly.\n",
    "\n",
    "A function signature typically includes :\n",
    "Function Name, Parameters (or arguments), Return type, Modifiers\n",
    "'''\n",
    "def add_func(a : int , b : int = 5) -> int :\n",
    "    return a + b\n",
    "\n",
    "add_func(2,1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fccb5053-1ba0-425f-8a92-c5d3b9138aa2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6efc4a2-767f-4c36-9793-55afd0067faf",
   "metadata": {},
   "source": [
    "### 6.Create a Python function that takes two arguments and returns their product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "600b63e5-e2eb-4522-8456-e07329d59013",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product of 6 and 3 : 18\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def product_func(a,b):\n",
    "    return a*b\n",
    "\n",
    "result = product_func(6,3)\n",
    "print(f\"Product of {6} and {3} : {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34582b57-68ae-4bdb-bc59-e45358d1fd61",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1e4264ff-f248-4417-8c77-f759c841f9a0",
   "metadata": {},
   "source": [
    "### Function Parameters and Arguments :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b34df2b-28ac-46fd-a065-b93443d908ed",
   "metadata": {},
   "source": [
    "### 1.Explain the concepts of formal parameters and actual arguments in Python functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2d25445e-5654-4f61-807b-3d2664c606ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello Durga, you are 29 years old.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "formal parameters : variables or placeholders defined in the function definition.\n",
    "formal parameters, often simply called \"parameters\" , are the variables that are defined  in a function's declaration.\n",
    "actual parameters : variables which are passed during function call.\n",
    "'''\n",
    "def greet(name, age):\n",
    "    #here, name and age are formal parameters.\n",
    "    print(f\"hello {name}, you are {age} years old.\")\n",
    "    \n",
    "# Actual arguments, often just called \"arguments,\" are the specific values or references that are passed to a function when it is called. \n",
    "#These values are then matched with the function's formal parameters, and the function is executed with these values.\n",
    "\n",
    "greet(\"Durga\", 29) # here, \"Durga\" and 29 are actual arguments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fe21dbd-7b11-45da-bd99-7ba0d549bb00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d269ebc-dd6a-4351-8949-3d1a087326cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "2.Write a Python program that defines a function with default argument values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "06226e52-c028-4b7b-a481-efae2f8c0def",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, User!\n",
      "Hello, Alice!\n",
      "Welcome, Bob!\n",
      "Hi, User!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def greet(name=\"User\", message=\"Hello\"):\n",
    "    print(f\"{message}, {name}!\")\n",
    "\n",
    "# Test the function with different scenarios:\n",
    "\n",
    "# Use both default values\n",
    "greet()  # Output: Hello, User!\n",
    "\n",
    "# Provide only the name argument, use default message\n",
    "greet(\"Alice\")  # Output: Hello, Alice!\n",
    "\n",
    "# Provide both arguments, overriding defaults\n",
    "greet(\"Bob\", \"Welcome\")  # Output: Welcome, Bob!\n",
    "\n",
    "# Provide only the message argument, use default name\n",
    "greet(message=\"Hi\")  # Output: Hi, User!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cb8c7d0-5b98-4ed6-a007-f21a64d49b21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "80842fa6-5762-4105-93d9-2d97fb4ddfd0",
   "metadata": {},
   "source": [
    "### 3.How do you use keyword arguments in Python function calls? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d67d1f06-75e7-4e12-a4bb-11cdb27966ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'City': 'USA', 'age': 24, 'message': 'gm'}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "use**symbol followed by name of the parameter in function definition.\n",
    "\n",
    "Example :\n",
    "'''\n",
    "def key_fun(**elements):\n",
    "    print(elements)\n",
    "    \n",
    "key_fun(City = 'USA', age = 24, message = 'gm')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ca5ada3-1745-490c-a349-4d9efb51e593",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e833049d-6cc0-407b-9d2e-fd6d4bb66437",
   "metadata": {},
   "source": [
    "### 4.Create a Python Function that accepts a variable number of arguments and calculates their sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5593a601-453f-4acf-b851-fae951eef5a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of elements is : 13\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def sum_var(*elements):\n",
    "    return sum(elements)\n",
    "\n",
    "n = sum_var(1,3,4,1,4)\n",
    "print(f\"Sum of elements is : {n}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "782238c5-ea6f-46a1-81f3-08699fcebf79",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f9b478fa-7b39-4f1b-b5e5-8f1da8e013b3",
   "metadata": {},
   "source": [
    "### 5.What is the purpose of the '*args' and '**kwargs' syntax in function parameter lists?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f7ab3719-d48e-4c64-ac8d-19c220cdac89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "{'a': 4, 'b': 5}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "'*args' : used to pass the variable number of arguments. if we use *args in function definition, we are\n",
    "allowed to pass variable arguments in function call.\n",
    "'**kwargs' : used to pass the keyword argument(key-value pairs) in functions.\n",
    "\n",
    "*args syntax allows a function to accept a variable number of positional arguments, \n",
    "while **kwargs allows a function to accept a variable number of keyword (named).\n",
    "'''\n",
    "def example_function(*args, **kwargs):\n",
    "    print(args)  # tuple of positional arguments\n",
    "    print(kwargs)  # dictionary of keyword arguments\n",
    "\n",
    "example_function(1, 2, 3, a=4, b=5)  # Outputs: (1, 2, 3)  {'a': 4, 'b': 5}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de284f8a-f0e5-4266-877d-70eb78331644",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da36b7f0-c142-41e7-a4e5-0c8b8f6e98de",
   "metadata": {},
   "source": [
    "### Return Values and Scoping :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e42d4b1d-dafe-4c55-a27b-cd7a0ba95f15",
   "metadata": {},
   "source": [
    "### 1.Describe the role of the 'return' statement in Python functions and provide examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a3b4f4f5-bd6b-4355-a243-56715fc8bcd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of two number : 7\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "return : used to provide the output of the functions and it will be processed further in the program.\n",
    "The return statement in python functions is used to send a result back to the caller and terminate the function's execution.\n",
    "\n",
    "Example :\n",
    "'''\n",
    "def add(a, b):\n",
    "    return a+b\n",
    "\n",
    "result = add(2,5) # result will be assigned the value 7\n",
    "print(f\"Addition of two number : {result}\")  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41b5b24c-e582-4752-86e3-47603a978007",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1298ef93-22ec-4a57-9f09-dcdaf7544054",
   "metadata": {},
   "source": [
    "### 2.Explain the concept of variable scope in Python, including local and global variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0ec132dd-f676-4447-8e93-b17ada8485f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "In python, the 'variable scope' defines the accessibility of the variables with in the program.\n",
    "\n",
    "'local' variables are defined within a function and only accessible inside it.\n",
    "example, variables defined in the functions.\n",
    "\n",
    "while 'global' variables are defined outside any function and are accessible throughout the module.\n",
    "'''\n",
    "a = 10   # global variable \n",
    "\n",
    "def example_func():\n",
    "    b = 4     # local variable\n",
    "    print(b)\n",
    "    \n",
    "example_func()  # output : 4\n",
    "print(a)    # output : 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42911285-b654-457b-98f9-b58091bc2010",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3a488c95-1b67-497e-8bb5-914016cca4fd",
   "metadata": {},
   "source": [
    "### 3.Write a Python program that demonstrates the use of global variables within functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7a427aad-8a6c-4ebc-a587-4457f3982ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value inside the function : 3\n",
      "value of global_a outside function : 5\n"
     ]
    }
   ],
   "source": [
    "\n",
    "global_a  = 5 # global variable \n",
    "\n",
    "def func():\n",
    "    global_a = 3 # Declare 'global_a' as a global variable to modify it\n",
    "    print(f\"value inside the function : {global_a}\")\n",
    "    \n",
    "func()\n",
    "print(f\"value of global_a outside function : {global_a}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f354d582-ff97-46a1-9449-b7c148c7fc6d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a111758f-6f6b-4561-9fe8-7b50c6b4b50e",
   "metadata": {},
   "source": [
    "### 4.Create a Python function that calculates the factorial of a number and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5fab9a21-d1a1-4e01-82da-9c60e648c6f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial of 7 is : 5040\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def fact(n):\n",
    "    fact = 1\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    for i in range(1, n+1):\n",
    "        fact = fact * i \n",
    "    \n",
    "    return fact\n",
    "\n",
    "number = 7\n",
    "print(f\"Factorial of {number} is : {fact(number)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d1d1108-c401-4912-939d-5de60ee53e21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b2fc74cb-9804-422f-b604-2ab4735aaeeb",
   "metadata": {},
   "source": [
    "### 5.How can you access variables defined outside a function from within the function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "65a77bac-cef4-43e2-aef4-5825587e6383",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm a global variable\n",
      "Modified global variable\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Global variable\n",
    "var = \"I'm a global variable\"\n",
    "\n",
    "def display_var():\n",
    "    # Directly referencing the global variable to read its value\n",
    "    print(var)\n",
    "\n",
    "def modify_var():\n",
    "    global var  # Declare 'var' as global to modify it\n",
    "    var = \"Modified global variable\"\n",
    "\n",
    "display_var()  # Outputs: I'm a global variable\n",
    "modify_var()\n",
    "display_var()  # Outputs: Modified global variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4d4711b-5f63-466f-a761-6ef288e01c51",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dd7f80f9-2597-45dd-bed1-022dd4b168dd",
   "metadata": {},
   "source": [
    "### Lambda Functions and Higher-Order Functions :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3936f2b-63e0-417b-bdde-f7abe5ac58c1",
   "metadata": {},
   "source": [
    "### 1.What are lambda functions in Python, and when are they typically used?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eef59f89-aad4-4c29-a654-d214a10dfafd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "Lambda functions in Python are small, anonymous, one-liner functions defined using the lambda keyword, typically used for short, simple \n",
    "operations on any iterables and no need to define function seperately.\n",
    "'''\n",
    "square = lambda x: x ** 2\n",
    "print(square(5))  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb53040d-fe1a-4e80-a8ab-8e87cd9d3ed3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4d6afb7a-c845-43cf-b55e-43f019e7cb08",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses lambda functions to sort a list of tuples based on the second element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8b9b40c9-afcf-4069-839c-a4a9cd77807d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list : [(1, 2), (3, 4), (5, 1), (3, 10)]\n",
      "Sorted list : [(5, 1), (1, 2), (3, 4), (3, 10)]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "tuples_list = [(1,2) , (3,4) , (5,1) , (3, 10)]\n",
    "sorted_list = sorted(tuples_list , key = lambda x : x[1])\n",
    "print(f\"Original list : {tuples_list}\")\n",
    "print(f\"Sorted list : {sorted_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dbaa030-9ec2-4f70-baa9-b52324f2b576",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4428b9eb-10cc-437c-af48-a27abdcee812",
   "metadata": {},
   "source": [
    "### 3.Explain the concept of higher-order functions in Python, and provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b92c903f-5a35-43ac-8fdf-dc275836eb0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "function which can accepts other functions as arguments and can return result as function is called higher-order functions.\n",
    "\n",
    "Example :\n",
    "'''\n",
    "def multiply(sum_n, x):\n",
    "    return sum_n(x)\n",
    "\n",
    "def sum_num(l):\n",
    "    return max(l)\n",
    "\n",
    "multiply(sum_num, [2,4,1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd29c814-94eb-4672-9740-f2ceeed3cde0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "16828cb8-cbd5-4de6-aaab-5d5ce40f0419",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f197f95e-837f-40cc-bb74-f6145677fbfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[28, 88]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "l = [ 28, 11, 23, 11, 88]\n",
    "\n",
    "def even_number(l):\n",
    "    list_element = []\n",
    "    for i  in l :\n",
    "        if i%2 == 0:\n",
    "            list_element.append(i)\n",
    "    return list_element\n",
    "\n",
    "a = lambda x : even_number(x)\n",
    "a(l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7bceb67-ee73-4679-8137-6fd9880cbe91",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cb11c4bc-36f3-4a8a-b0ed-9304bc5ea643",
   "metadata": {},
   "source": [
    "### Built-in Functions :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbbf287c-9e55-459a-9342-53c2bf86483e",
   "metadata": {},
   "source": [
    "### 1.Describe the role of built-in functions like 'len()','max()' and 'min()' in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "112ef839-5ec4-4b23-809b-be8c8b3ca441",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [4, 15, 9, 1, 12]\n",
      "Length of the list: 5\n",
      "Largest number: 15\n",
      "Smallest number: 1\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''In Python, len() returns the number of items in an object,\n",
    "while max() and min() return the largest and smallest values \n",
    "from an iterable or set of arguments, respectively.\n",
    "'''\n",
    "\n",
    "numbers = [4, 15, 9, 1, 12]\n",
    "length = len(numbers)  # Get the number of items in the list\n",
    "largest = max(numbers)  # Get the largest number in the list\n",
    "smallest = min(numbers)  # Get the smallest number in the list\n",
    "\n",
    "print(f\"List: {numbers}\")\n",
    "print(f\"Length of the list: {length}\")\n",
    "print(f\"Largest number: {largest}\")\n",
    "print(f\"Smallest number: {smallest}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2f28e5b-60af-4746-8c80-08fe6239108a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24c7d211-891e-4b0a-8fd9-a3d48e14be6e",
   "metadata": {},
   "source": [
    "### 2.Write a Python program that uses the 'map()' function to apply a function to each element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "94978f7d-62ce-49e3-ae89-70b8d678a1e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "old list : [1, 2, 3, 4, 5, 6]\n",
      "list of squares : [1, 4, 9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "l = [1, 2, 3, 4, 5, 6]\n",
    "print(f\"old list : {l}\")\n",
    "\n",
    "def square_func(x):\n",
    "    return x**2\n",
    "\n",
    "list_sq = list(map(square_func, l))\n",
    "print(f\"list of squares : {list_sq}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af91f043-c12d-4371-a034-8769e2fb1c69",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "319fe925-1914-4c9e-9953-0a432f34f6b9",
   "metadata": {},
   "source": [
    "### 3.How does the 'filter()' function work in Python, and when would you use it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5111c4e8-f8d3-414c-a03b-695b0e25d23c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example list : [1, 2, 3, 4, 5, 123, 45, 12]\n",
      "Even number list : [2, 4, 12]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "filter() - function takes two arguments (function and iterable). Apply function on each and every element \n",
    "of the iterable and returns when condition is true.\n",
    "'''\n",
    "l = [1, 2, 3, 4, 5, 123, 45, 12]\n",
    "print(f\"Example list : {l}\")\n",
    "\n",
    "def even_num(l):\n",
    "    return l % 2 == 0\n",
    "    \n",
    "even_number = list(filter(even_num , l))\n",
    "print(f\"Even number list : {even_number}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1e33866-3921-4e0d-ab02-1aaf08ec84a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "52795a99-c301-4f54-a560-e7c94ece30c3",
   "metadata": {},
   "source": [
    "### 4.Create a Python program that uses the 'reduce()' function to find the product of all elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "97438a5b-b31a-431d-9cd3-a4190f098dfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example list : [1, 2, 3, 4, 5, 6, 10]\n",
      "Product of all elements in a list : 7200\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from functools import reduce\n",
    "def multiply_func(x , y):\n",
    "    return x*y\n",
    "\n",
    "l = [1, 2, 3, 4, 5, 6, 10]\n",
    "print(f\"Example list : {l}\")\n",
    "product = reduce(multiply_func, l)\n",
    "print(f\"Product of all elements in a list : {product}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72c39372-3b5f-430c-99f0-d016a85d2067",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4140d894-58ac-4b3b-83a2-f2411ca1bc19",
   "metadata": {},
   "source": [
    "### Function Documentation and Best Practices :-\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a66e631-4b8c-46ff-8423-49e3e8490e03",
   "metadata": {},
   "source": [
    "### 1.Explain the purpose of docstrings in Python functions and how to write them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f61ad7dc-0470-46ad-a793-6f5771c66d53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is an example function's docstring.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "Docstrings in Python provide a concise explanation of a function's purpose and usage, \n",
    "and are placed immediately after the function header within triple quotes. \n",
    "They can be accessed using the help() function or the .__doc__ attribute.\n",
    "\n",
    "It contains description of the function, details about the function parameters\n",
    "and return statement.\n",
    "\n",
    "example\n",
    "\n",
    "\"\"\"\n",
    "Description:\n",
    "    To perform some task\n",
    "    \n",
    "Parameters:\n",
    "    a int : number1\n",
    "    b int : number2\n",
    "    \n",
    "return:\n",
    "    result of task\n",
    "\"\"\"    \n",
    "\n",
    "example\n",
    "'''\n",
    "\n",
    "def example_function():\n",
    "    \"\"\"This is an example function's docstring.\"\"\"\n",
    "    pass\n",
    "\n",
    "print(example_function.__doc__)  # Outputs: This is an example function's docstring.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "710e9916-c2c5-404b-8318-bf29e7cd573b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9af3fdc5-e096-4f28-803e-897b0827ee05",
   "metadata": {},
   "source": [
    "### 2.Describe some best practices for naming functions and variables in Python, including naming conventions and guidelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70739002-dacc-4b51-bfa7-89ab75037c85",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "'''\n",
    "Best practices for naming functions and variables in Python:\n",
    "\n",
    "1.Descriptive Names: Choose names that describe the purpose or meaning of the variable or function. \n",
    "For instance, word_list is more descriptive than wl.\n",
    "\n",
    "2.Use Lowercase for Variables and Functions: Names should be in lowercase, with words separated by underscores.\n",
    "For example: calculate_average, user_name.\n",
    "\n",
    "3.Avoid Using Built-in Names: Do not override Python built-in names, such as list, str, or max.\n",
    "\n",
    "4.Avoid Single-letter Variables: Except for common usage, like i, j, k in loops, or x, y, z in mathematical operations.\n",
    "\n",
    "5.Use Uppercase for Constants: Constants should be in uppercase with underscores separating words, \n",
    "e.g., PI_VALUE or MAX_LENGTH.\n",
    "\n",
    "6.Function Names Should Indicate Actions: Since functions typically perform actions, their names often have verbs, \n",
    "e.g., calculate_sum or print_message.\n",
    "\n",
    "7.Avoid Using Abbreviations: Unless they're widely accepted, like num for number or info for information.\n",
    "\n",
    "8.Use CamelCase for Classes: Class names should start with an uppercase letter, and every new word should also begin\n",
    "\n",
    "\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4faffea4-6bc3-4126-b1a1-29594cb83db5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}