17th_Sept_FSDS_Pro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f4ced5db-1398-4b42-9464-18c386dc83ba",
   "metadata": {},
   "source": [
    "                                                     For Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811e988f-f8d8-43d3-a836-4740d9733990",
   "metadata": {},
   "source": [
    "1. Write a Python program to print numbers from 1 to 10 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bafb4157-2959-4bef-bb3b-f910f9a47c54",
   "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": [
    "for number in range(1, 11):\n",
    "    print(number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46f1d1c2-4259-440e-a406-3fb879e9e0eb",
   "metadata": {},
   "source": [
    "2. Explain the difference between a for loop and a while loop in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "488435ae-0ec8-46bf-98da-96f0de307d2a",
   "metadata": {},
   "source": [
    "In Python, both for and while loops are used to execute a block of code repeatedly, but they have different use cases and behaviors.\n",
    "\n",
    "For Loop:\n",
    "Iteration over a Sequence:\n",
    "\n",
    "1- A for loop is used to iterate over a sequence (like a list, tuple, dictionary, set, or string) or other iterable objects.\n",
    "2- The number of iterations is known and fixed before the loop starts.\n",
    "\n",
    "While Loop:\n",
    "Condition-Based Iteration:\n",
    "\n",
    "1- A while loop is used to repeat a block of code as long as a condition is true.\n",
    "2- The number of iterations is not necessarily known beforehand. The loop continues until the specified condition becomes false."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ad16d3-8189-40af-abc7-3efc12005453",
   "metadata": {},
   "source": [
    "3. Write a Python program to calculate the sum of all numbers from 1 to 100 using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f9dc0f22-f627-4785-b011-5c981bafc534",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of all numbers from 1 to 100 is: 5050\n"
     ]
    }
   ],
   "source": [
    "total_sum = 0\n",
    " \n",
    "for number in range(1, 101):\n",
    "    total_sum += number\n",
    " \n",
    "print(\"The sum of all numbers from 1 to 100 is:\", total_sum)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c07f6e9-d322-43d1-b377-5ac7b4f1aba3",
   "metadata": {},
   "source": [
    "4. How do you iterate through a list using a for loop in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8add231f-b7f1-4f1c-83b0-a122757e8dd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n",
      "date\n"
     ]
    }
   ],
   "source": [
    " fruits = ['apple', 'banana', 'cherry', 'date']\n",
    " \n",
    "for fruit in fruits:\n",
    "    print(fruit)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b875e755-0a75-41ed-a4c4-a50b111a833e",
   "metadata": {},
   "source": [
    "5. Write a Python program to find the product of all elements in a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c1dd42fc-702a-439f-ad6a-a914734b11f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of all elements in the list is: 120\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5] \n",
    "product = 1 \n",
    "for number in numbers:\n",
    "    product *= number \n",
    "print(\"The product of all elements in the list is:\", product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31355f03-41ea-4d8b-b8f8-54c2eaaa4d56",
   "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": 1,
   "id": "6c3e3473-4be9-4156-b0aa-ca9e676166e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "for number in range(1, 21):\n",
    "    if number % 2 == 0:\n",
    "        print(number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b762292-4a0a-436c-8876-033a41616335",
   "metadata": {},
   "source": [
    "7. Write a Python program that calculates the factorial of a number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f3e0c90f-7b23-4508-ab74-b86baf713923",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    " def factorial(n):\n",
    "    result = 1\n",
    "    for i in range(1, n + 1):\n",
    "        result *= i\n",
    "    return result \n",
    "number = int(input(\"Enter a number: \")) \n",
    "print(f\"The factorial of {number} is {factorial(number)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7cc3bd1-81bd-41d8-b31d-95e1cda83ce3",
   "metadata": {},
   "source": [
    "8. How can you iterate through the characters of a string using a for loop in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "433d6af3-fda1-4246-b4d1-18f4d91a75b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      ",\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "my_string = \"Hello, World!\"\n",
    " \n",
    "for char in my_string:\n",
    "    print(char)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36971d53-2816-47a6-9d85-2b153d1d40bb",
   "metadata": {},
   "source": [
    "9. Write a Python program to find the largest number in a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ee3047a7-575e-42ba-a641-9e29c74d11a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest number in the list is 74\n"
     ]
    }
   ],
   "source": [
    "def find_largest_number(numbers): \n",
    "    largest = numbers[0] \n",
    "    for number in numbers: \n",
    "        if number > largest:\n",
    "            largest = number\n",
    "    \n",
    "    return largest \n",
    "numbers = [3, 41, 12, 9, 74, 15] \n",
    "print(f\"The largest number in the list is {find_largest_number(numbers)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "560ce657-590d-4266-a03e-44ec8c133501",
   "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": 7,
   "id": "10ff2ce8-af4b-4615-ba15-820e1e946fbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the limit:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 "
     ]
    }
   ],
   "source": [
    "     a, b = 0, 1\n",
    "    print(a, end=\" \")\n",
    "    while b <= limit:\n",
    "        print(b, end=\" \")\n",
    "        a, b = b, a + b \n",
    "limit = int(input(\"Enter the limit: \")) \n",
    "fibonacci_sequence(limit)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d4d819d-9b60-4eea-a1c0-986d265a920a",
   "metadata": {},
   "source": [
    "11. Write a Python program to count the number of vowels in a given string using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9de90038-a6a6-4adb-bd1e-9c73deca9e52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amiT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of vowels in the string is 2\n"
     ]
    }
   ],
   "source": [
    " def count_vowels(input_string):\n",
    "    vowels = \"aeiouAEIOU\"\n",
    "    count = 0\n",
    "    for char in input_string:\n",
    "        if char in vowels:\n",
    "            count += 1\n",
    "    return count \n",
    "input_string = input(\"Enter a string: \") \n",
    "print(f\"The number of vowels in the string is {count_vowels(input_string)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06dfea9-3360-40b2-b6de-2ffacfe067a5",
   "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": 10,
   "id": "1608a0f1-8db8-4d67-86ce-54962108f391",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  23\n",
      "Enter the limit up to which the table should be generated (default is 10):  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 x 1 = 23\n",
      "23 x 2 = 46\n",
      "23 x 3 = 69\n",
      "23 x 4 = 92\n",
      "23 x 5 = 115\n"
     ]
    }
   ],
   "source": [
    " def multiplication_table(number, up_to=10):\n",
    "    for i in range(1, up_to + 1):\n",
    "        print(f\"{number} x {i} = {number * i}\") \n",
    "number = int(input(\"Enter a number: \"))\n",
    " \n",
    "limit = int(input(\"Enter the limit up to which the table should be generated (default is 10): \")) \n",
    "multiplication_table(number, limit)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f13012a8-493d-45f3-80e1-39a85659d6bb",
   "metadata": {},
   "source": [
    "13. Write a Python program to reverse a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7ca24baf-69f1-4357-98d0-297cfe4a842a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5]\n",
      "Reversed list: [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    " def reverse_list(input_list):\n",
    "    reversed_list = []\n",
    "    for i in range(len(input_list) - 1, -1, -1):\n",
    "        reversed_list.append(input_list[i])\n",
    "    return reversed_list \n",
    "input_list = [1, 2, 3, 4, 5] \n",
    "print(f\"Original list: {input_list}\")\n",
    "print(f\"Reversed list: {reverse_list(input_list)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d2061b4-10d7-46dd-9a6a-4295b47b5fd5",
   "metadata": {},
   "source": [
    "14. Write a Python program to find the common elements between two lists using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "33f158a8-143c-4f88-bd74-43dcca132d14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1: [1, 2, 3, 4, 5]\n",
      "List 2: [4, 5, 6, 7, 8]\n",
      "Common elements: [4, 5]\n"
     ]
    }
   ],
   "source": [
    " def find_common_elements(list1, list2):\n",
    "    common_elements = []\n",
    "    for element in list1:\n",
    "        if element in list2 and element not in common_elements:\n",
    "            common_elements.append(element)\n",
    "    return common_elements \n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [4, 5, 6, 7, 8] \n",
    "print(f\"List 1: {list1}\")\n",
    "print(f\"List 2: {list2}\")\n",
    "print(f\"Common elements: {find_common_elements(list1, list2)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af01c875-1c8d-4675-9338-c74ef1d442a9",
   "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": 15,
   "id": "84400fad-00a5-4424-8daf-b0c2e5419f1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys:\n",
      "a\n",
      "b\n",
      "c\n",
      "\n",
      "Values:\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "Key-Value Pairs:\n",
      "Key: a, Value: 1\n",
      "Key: b, Value: 2\n",
      "Key: c, Value: 3\n"
     ]
    }
   ],
   "source": [
    " my_dict = {'a': 1, 'b': 2, 'c': 3} \n",
    "print(\"Keys:\")\n",
    "for key in my_dict:\n",
    "    print(key) \n",
    "print(\"\\nValues:\")\n",
    "for value in my_dict.values():\n",
    "    print(value) \n",
    "print(\"\\nKey-Value Pairs:\")\n",
    "for key, value in my_dict.items():\n",
    "    print(f\"Key: {key}, Value: {value}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f3ef6aa-5e39-4ea4-9654-6116cd9d753e",
   "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": 13,
   "id": "d5309567-978e-4419-9e4d-193c3a10ff1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  4\n",
      "Enter the second number:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The GCD of 4 and 4 is 4\n"
     ]
    }
   ],
   "source": [
    " def find_gcd(a, b): \n",
    "    min_num = min(a, b) \n",
    "    gcd = 1 \n",
    "    for i in range(1, min_num + 1):\n",
    "        if a % i == 0 and b % i == 0:\n",
    "            gcd = i\n",
    "    \n",
    "    return gcd \n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \")) \n",
    "print(f\"The GCD of {num1} and {num2} is {find_gcd(num1, num2)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "509ea1f9-edaf-433e-b78a-8011263c4b5b",
   "metadata": {},
   "source": [
    "17. Create a Python program that checks if a string is a palindrome using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4d184570-b09e-4528-912e-cf0a92b64e1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  jhbf\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'jhbf' is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    " def is_palindrome(s): \n",
    "    s = s.replace(\" \", \"\").lower() \n",
    "    length = len(s) \n",
    "    for i in range(length // 2): \n",
    "        if s[i] != s[length - 1 - i]:\n",
    "            return False\n",
    "    \n",
    "    return True \n",
    "input_string = input(\"Enter a string: \") \n",
    "if is_palindrome(input_string):\n",
    "    print(f\"'{input_string}' is a palindrome.\")\n",
    "else:\n",
    "    print(f\"'{input_string}' is not a palindrome.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf8cdc89-6ed1-4233-a9b9-5bcb9d62694c",
   "metadata": {},
   "source": [
    "18. Write a Python program to remove duplicates from a list using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "779ab5cf-fcf1-4a53-8769-2383d04cc328",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 2, 4, 5, 3, 6, 4]\n",
      "List after removing duplicates: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    " def remove_duplicates(input_list): \n",
    "    unique_list = [] \n",
    "    for item in input_list: \n",
    "        if item not in unique_list:\n",
    "            unique_list.append(item)\n",
    "    \n",
    "    return unique_list \n",
    "input_list = [1, 2, 3, 2, 4, 5, 3, 6, 4] \n",
    "print(f\"Original list: {input_list}\")\n",
    "print(f\"List after removing duplicates: {remove_duplicates(input_list)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a067d020-b238-4a99-a505-6c874e50f573",
   "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": 19,
   "id": "a8464649-178e-4219-8014-74ac51002e1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a sentence:  jkdfv udfv\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of words in the sentence is 2\n"
     ]
    }
   ],
   "source": [
    " def count_words(sentence): \n",
    "    words = sentence.split() \n",
    "    word_count = 0 \n",
    "    for word in words:\n",
    "        word_count += 1\n",
    "    \n",
    "    return word_count \n",
    "sentence = input(\"Enter a sentence: \") \n",
    "print(f\"The number of words in the sentence is {count_words(sentence)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "516a022b-f923-4cd3-a2df-ff3327c9e94d",
   "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": 20,
   "id": "6ac10772-4eb9-4fcd-8dcb-73236097390d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of all odd numbers from 1 to 50 is 625\n"
     ]
    }
   ],
   "source": [
    " def sum_of_odds(start, end):\n",
    "    total_sum = 0 \n",
    "    for num in range(start, end + 1): \n",
    "        if num % 2 != 0:\n",
    "            total_sum += num\n",
    "    return total_sum \n",
    "start = 1\n",
    "end = 50 \n",
    "print(f\"The sum of all odd numbers from {start} to {end} is {sum_of_odds(start, end)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6637b36-ca30-4cc0-bc9f-df590e14d37e",
   "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": 22,
   "id": "4d1bfdfb-b907-4f95-b677-e257defe60eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year to check if it's a leap year:  2024\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024 is a leap year.\n"
     ]
    }
   ],
   "source": [
    " def is_leap_year(year): \n",
    "    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    " \n",
    "def check_leap_years(start_year, end_year):\n",
    "    for year in range(start_year, end_year + 1):\n",
    "        if is_leap_year(year):\n",
    "            print(f\"{year} is a leap year.\")\n",
    "        else:\n",
    "            print(f\"{year} is not a leap year.\") \n",
    "year_to_check = int(input(\"Enter a year to check if it's a leap year: \")) \n",
    "if is_leap_year(year_to_check):\n",
    "    print(f\"{year_to_check} is a leap year.\")\n",
    "else:\n",
    "    print(f\"{year_to_check} is not a leap year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c299b536-ccab-4a8c-92ac-624a6ab4b5d3",
   "metadata": {},
   "source": [
    "22. Create a Python program that calculates the square root of a number using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "de00d196-e1df-4bd7-9672-53cb98d49006",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number to calculate its square root:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The square root of 5.0 is approximately 2.23606797749979.\n"
     ]
    }
   ],
   "source": [
    " def sqrt(number, tolerance=1e-10, max_iterations=1000):\n",
    "    if number < 0:\n",
    "        raise ValueError(\"Cannot compute the square root of a negative number.\") \n",
    "    guess = number\n",
    "    iteration = 0\n",
    "    \n",
    "    while iteration < max_iterations: \n",
    "        next_guess = 0.5 * (guess + number / guess) \n",
    "        if abs(next_guess - guess) < tolerance:\n",
    "            return next_guess \n",
    "        guess = next_guess\n",
    "        iteration += 1\n",
    "    \n",
    "    return guess \n",
    "number = float(input(\"Enter a number to calculate its square root: \")) \n",
    "try:\n",
    "    result = sqrt(number)\n",
    "    print(f\"The square root of {number} is approximately {result}.\")\n",
    "except ValueError as e:\n",
    "    print(e)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f718dad2-05a1-4873-9753-5278ac95eea9",
   "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": 26,
   "id": "b078171e-168d-42c0-a280-cd39aeab9b06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The LCM of 5 and 5 is 5\n"
     ]
    }
   ],
   "source": [
    "def find_gcd(a, b): \n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a \n",
    "def find_lcm(a, b):\n",
    "    gcd = find_gcd(a, b)\n",
    "    lcm = abs(a * b) // gcd\n",
    "    return lcm \n",
    "num1 = int(input(\"Enter the first number: \"))\n",
    "num2 = int(input(\"Enter the second number: \")) \n",
    "print(f\"The LCM of {num1} and {num2} is {find_lcm(num1, num2)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28ef7780-c57f-44f2-a1e5-0dc856f53321",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dfc469bd-5048-43da-b312-c9e00246521a",
   "metadata": {},
   "source": [
    "                                                      If else "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c4ae55-dc82-445c-87a3-c45b9ed546f5",
   "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": 28,
   "id": "bf2c79b2-0cad-403e-8009-3b1aef236fb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 5.0 is positive.\n"
     ]
    }
   ],
   "source": [
    "number = float(input(\"Enter a number: \"))\n",
    " \n",
    "if number > 0:\n",
    "    print(f\"The number {number} is positive.\")\n",
    "elif number < 0:\n",
    "    print(f\"The number {number} is negative.\")\n",
    "else:\n",
    "    print(f\"The number {number} is zero.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df210df1-c243-465a-b13a-626619ac0e06",
   "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": 29,
   "id": "09dd6f79-fd43-4068-a4e0-bfadf9bec135",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 5 is odd.\n"
     ]
    }
   ],
   "source": [
    "number = int(input(\"Enter a number: \"))\n",
    " \n",
    "if number % 2 == 0:\n",
    "    print(f\"The number {number} is even.\")\n",
    "else:\n",
    "    print(f\"The number {number} is odd.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aade7b1a-fbfe-417d-975d-04bdab0daea8",
   "metadata": {},
   "source": [
    "3. How can you use nested if-else statements in Python, and provide an example?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "df26840f-7a05-41df-9a4c-30fd2916613b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the score:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The grade for the score 5 is F.\n"
     ]
    }
   ],
   "source": [
    " score = int(input(\"Enter the score: \"))\n",
    " \n",
    "if score >= 90:\n",
    "    grade = 'A'\n",
    "else:\n",
    "    if score >= 80:\n",
    "        grade = 'B'\n",
    "    else:\n",
    "        if score >= 70:\n",
    "            grade = 'C'\n",
    "        else:\n",
    "            if score >= 60:\n",
    "                grade = 'D'\n",
    "            else:\n",
    "                grade = 'F' \n",
    "print(f\"The grade for the score {score} is {grade}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ecbf342-c1c7-483c-99fd-5437fced15fc",
   "metadata": {},
   "source": [
    "4. Write a Python program to determine the largest of three numbers using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "526e8fb3-d494-47f7-b167-c3ab6254deeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first number:  5\n",
      "Enter the second number:  7\n",
      "Enter the third number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest number among 5.0, 7.0, and 5.0 is 7.0.\n"
     ]
    }
   ],
   "source": [
    "num1 = float(input(\"Enter the first number: \"))\n",
    "num2 = float(input(\"Enter the second number: \"))\n",
    "num3 = float(input(\"Enter the third number: \"))\n",
    " \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 among {num1}, {num2}, and {num3} is {largest}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "985f2a12-630d-4e77-8cb6-30f8fe00677e",
   "metadata": {},
   "source": [
    "5. Write a Python program that calculates the absolute value of a number using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "54d68ee4-327b-409b-a86a-34e9cc8c339b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The absolute value of 54.0 is 54.0.\n"
     ]
    }
   ],
   "source": [
    "number = float(input(\"Enter a number: \"))\n",
    " \n",
    "if number < 0:\n",
    "    absolute_value = -number\n",
    "else:\n",
    "    absolute_value = number\n",
    " \n",
    "print(f\"The absolute value of {number} is {absolute_value}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68a856aa-59f6-4657-9fdf-7331d919b808",
   "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": 34,
   "id": "b3af5edc-67f6-46a8-afb3-e13cd0c815a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a character:  MIT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a single alphabetic character.\n"
     ]
    }
   ],
   "source": [
    "char = input(\"Enter a character: \").lower()\n",
    " \n",
    "if len(char) != 1 or not char.isalpha():\n",
    "    print(\"Please enter a single alphabetic character.\")\n",
    "else: \n",
    "    if char in ('a', 'e', 'i', 'o', 'u'):\n",
    "        print(f\"The character '{char}' is a vowel.\")\n",
    "    else:\n",
    "        print(f\"The character '{char}' is a consonant.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31991d52-240c-4c66-9971-ea007f0a4051",
   "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": 35,
   "id": "5bb3166f-b9ec-4066-ac8b-d4e472ddc71f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age:  56\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are eligible to vote.\n"
     ]
    }
   ],
   "source": [
    " age = int(input(\"Enter your age: \")) \n",
    "if age >= 18:\n",
    "    print(\"You are eligible to vote.\")\n",
    "else:\n",
    "    print(\"You are not eligible to vote.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ec2cf0-8101-4b3d-9c36-8424516f7de9",
   "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": 37,
   "id": "1ea1c738-c0ac-4062-99af-cdf3b740ddfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the purchase amount:  520\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Purchase amount: rs520.00\n",
      "Discount amount: rs156.00\n",
      "Final price after discount: rs364.00\n"
     ]
    }
   ],
   "source": [
    "purchase_amount = float(input(\"Enter the purchase amount: \")) \n",
    "if purchase_amount < 50:\n",
    "    discount_rate = 0.0\n",
    "elif purchase_amount <= 100:\n",
    "    discount_rate = 0.10\n",
    "elif purchase_amount <= 200:\n",
    "    discount_rate = 0.20\n",
    "else:\n",
    "    discount_rate = 0.30 \n",
    "discount_amount = purchase_amount * discount_rate\n",
    "final_price = purchase_amount - discount_amount \n",
    "print(f\"Purchase amount: rs{purchase_amount:.2f}\")\n",
    "print(f\"Discount amount: rs{discount_amount:.2f}\")\n",
    "print(f\"Final price after discount: rs{final_price:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c767c2e8-1800-4c5c-be70-4653a0e207fb",
   "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": 38,
   "id": "dda5e0d2-1486-4f78-bdf7-9706e7ec5a22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  582.\n",
      "Enter the lower bound of the range:  4\n",
      "Enter the upper bound of the range:  43.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 582.0 is not within the range [4.0, 43.0].\n"
     ]
    }
   ],
   "source": [
    "number = float(input(\"Enter a number: \")) \n",
    "lower_bound = float(input(\"Enter the lower bound of the range: \"))\n",
    "upper_bound = float(input(\"Enter the upper bound of the range: \")) \n",
    "if lower_bound <= number <= upper_bound:\n",
    "    print(f\"The number {number} is within the range [{lower_bound}, {upper_bound}].\")\n",
    "else:\n",
    "    print(f\"The number {number} is not within the range [{lower_bound}, {upper_bound}].\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e6d2872-8b0f-4f7a-8e47-cfe46a0e5afa",
   "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": 39,
   "id": "50a664ab-fae7-4bda-a1b9-ac6ec87a04fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the student's score:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The grade for the score 50.0 is F.\n"
     ]
    }
   ],
   "source": [
    "score = float(input(\"Enter the student's score: \")) \n",
    "if 90 <= score <= 100:\n",
    "    grade = 'A'\n",
    "elif 80 <= score < 90:\n",
    "    grade = 'B'\n",
    "elif 70 <= score < 80:\n",
    "    grade = 'C'\n",
    "elif 60 <= score < 70:\n",
    "    grade = 'D'\n",
    "elif 0 <= score < 60:\n",
    "    grade = 'F'\n",
    "else:\n",
    "    grade = None \n",
    "if grade:\n",
    "    print(f\"The grade for the score {score} is {grade}.\")\n",
    "else:\n",
    "    print(\"Invalid score. Please enter a score between 0 and 100.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f20e1c-33dd-4a50-bc49-d2088cefae0a",
   "metadata": {},
   "source": [
    "11. Write a Python program to check if a string is empty or not using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c059f241-5267-4df1-8fbc-ac26001bec79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  hjdv\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string is not empty.\n"
     ]
    }
   ],
   "source": [
    " user_string = input(\"Enter a string: \") \n",
    "if user_string:\n",
    "    print(\"The string is not empty.\")\n",
    "else:\n",
    "    print(\"The string is empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "848d494c-ca34-4f53-8b11-1b3e699aabed",
   "metadata": {},
   "source": [
    "12. Create a Python program that identifies the type of a triangle (e.g., equilateral, isosceles, or scalene) based on input values using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "be034ec9-9ba9-4455-bc7e-df8e62919751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the length of the first side:  5\n",
      "Enter the length of the second side:  5\n",
      "Enter the length of the third side:  52\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The triangle with sides 5.0, 5.0, and 52.0 is Not a valid triangle.\n"
     ]
    }
   ],
   "source": [
    "side1 = float(input(\"Enter the length of the first side: \"))\n",
    "side2 = float(input(\"Enter the length of the second side: \"))\n",
    "side3 = float(input(\"Enter the length of the third side: \")) \n",
    "if (side1 + side2 > side3) and (side1 + side3 > side2) and (side2 + side3 > side1): \n",
    "    if side1 == side2 == side3:\n",
    "        triangle_type = \"Equilateral\"\n",
    "    elif side1 == side2 or side1 == side3 or side2 == side3:\n",
    "        triangle_type = \"Isosceles\"\n",
    "    else:\n",
    "        triangle_type = \"Scalene\"\n",
    "else:\n",
    "    triangle_type = \"Not a valid triangle\"\n",
    "\n",
    "# Output: the type of the triangle\n",
    "print(f\"The triangle with sides {side1}, {side2}, and {side3} is {triangle_type}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ade4886-9916-4b09-9300-677526105013",
   "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": 44,
   "id": "40cc1093-4d17-4e2a-bc3b-e129d1afb4ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number (1-7) to find the day of the week:  52\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid number. Please enter a number between 1 and 7.\n"
     ]
    }
   ],
   "source": [
    " number = int(input(\"Enter a number (1-7) to find the day of the week: \")) \n",
    "if number == 1:\n",
    "    day = \"Monday\"\n",
    "elif number == 2:\n",
    "    day = \"Tuesday\"\n",
    "elif number == 3:\n",
    "    day = \"Wednesday\"\n",
    "elif number == 4:\n",
    "    day = \"Thursday\"\n",
    "elif number == 5:\n",
    "    day = \"Friday\"\n",
    "elif number == 6:\n",
    "    day = \"Saturday\"\n",
    "elif number == 7:\n",
    "    day = \"Sunday\"\n",
    "else:\n",
    "    day = \"Invalid number. Please enter a number between 1 and 7.\" \n",
    "print(day)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "857f4aac-909b-463f-bfee-57e0b7fcdd0a",
   "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": 45,
   "id": "49a5593a-d7bd-4baa-9075-6485716a3aed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  525\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "525 is not a leap year.\n"
     ]
    }
   ],
   "source": [
    "def is_leap_year(year):\n",
    "    \"\"\"\n",
    "    Determine if a year is a leap year.\n",
    "    A year is a leap year if:\n",
    "    - It is divisible by 4, and\n",
    "    - It is not divisible by 100, unless\n",
    "    - It is also divisible by 400.\n",
    "    \"\"\"\n",
    "    if (year % 4 == 0):\n",
    "        if (year % 100 == 0):\n",
    "            if (year % 400 == 0):\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "        else:\n",
    "            return True\n",
    "    else:\n",
    "        return False \n",
    "year = int(input(\"Enter a year: \")) \n",
    "if is_leap_year(year):\n",
    "    print(f\"{year} is a leap year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a leap year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7646252c-90e4-4e5e-ac8c-6c3e2cb037df",
   "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": 46,
   "id": "36d45fe7-931c-405f-af9b-9f601f68bc46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The square root of 55.0 is 7.416198487095663.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def calculate_square_root(number): \n",
    "    assert number >= 0, \"The number must be non-negative for square root calculation.\" \n",
    "    return math.sqrt(number) \n",
    "number = float(input(\"Enter a number: \")) \n",
    "if number < 0:\n",
    "    print(\"Invalid input. Number must be non-negative.\")\n",
    "else: \n",
    "    result = calculate_square_root(number)\n",
    "    print(f\"The square root of {number} is {result}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfdd4a6a-c5bb-4c69-872f-0afe29670394",
   "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": 47,
   "id": "7ed2f53e-31ed-4214-9477-008a45c57bb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age:  545\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are eligible for the senior citizen discount.\n"
     ]
    }
   ],
   "source": [
    "def check_senior_discount(age):\n",
    "    \"\"\"\n",
    "    Determine if a person is eligible for a senior citizen discount.\n",
    "    Eligibility criteria: Age must be 65 or older.\n",
    "    \"\"\"\n",
    "    if age >= 65:\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "age = int(input(\"Enter your age: \")) \n",
    "if check_senior_discount(age):\n",
    "    print(\"You are eligible for the senior citizen discount.\")\n",
    "else:\n",
    "    print(\"You are not eligible for the senior citizen discount.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98cba4a7-3b1a-4210-bdd7-85d8220a1896",
   "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": 48,
   "id": "0af785ae-f89a-4aec-a8ca-2a4f3ef3f582",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a single character:  rjgh'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid input. Please enter exactly one character.\n",
      "The character 'rjgh'' is Lowercase.\n"
     ]
    }
   ],
   "source": [
    "def categorize_character(char):\n",
    "    \"\"\"\n",
    "    Categorize a character as uppercase, lowercase, or neither.\n",
    "    \"\"\"\n",
    "    if char.isupper():\n",
    "        return \"Uppercase\"\n",
    "    elif char.islower():\n",
    "        return \"Lowercase\"\n",
    "    else:\n",
    "        return \"Neither\" \n",
    "char = input(\"Enter a single character: \") \n",
    "if len(char) != 1:\n",
    "    print(\"Invalid input. Please enter exactly one character.\") \n",
    "    category = categorize_character(char)\n",
    "    print(f\"The character '{char}' is {category}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ed20b5-3ad5-4247-8ebb-a1db008f6c5b",
   "metadata": {},
   "source": [
    "18.Write a Python program to determine the roots of a quadratic equation using if-else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "34db0ad7-814d-4fe9-9d7d-d8ff97af51a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the coefficient a:  .55\n",
      "Enter the coefficient b:  .248\n",
      "Enter the coefficient c:  .2144\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complex roots: -0.22545454545454544 + 0.5822271290072853i and -0.22545454545454544 - 0.5822271290072853i\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def find_roots(a, b, c):\n",
    "    \"\"\"\n",
    "    Determine the roots of a quadratic equation ax^2 + bx + c = 0.\n",
    "    \"\"\"\n",
    "    discriminant = b**2 - 4*a*c\n",
    "    \n",
    "    if discriminant > 0: \n",
    "        root1 = (-b + math.sqrt(discriminant)) / (2 * a)\n",
    "        root2 = (-b - math.sqrt(discriminant)) / (2 * a)\n",
    "        return f\"Two distinct real roots: {root1} and {root2}\"\n",
    "    elif discriminant == 0: \n",
    "        root = -b / (2 * a)\n",
    "        return f\"One real root: {root}\"\n",
    "    else: \n",
    "        real_part = -b / (2 * a)\n",
    "        imaginary_part = math.sqrt(-discriminant) / (2 * a)\n",
    "        return f\"Complex roots: {real_part} + {imaginary_part}i and {real_part} - {imaginary_part}i\" \n",
    "a = float(input(\"Enter the coefficient a: \"))\n",
    "b = float(input(\"Enter the coefficient b: \"))\n",
    "c = float(input(\"Enter the coefficient c: \"))\n",
    " \n",
    "if a == 0:\n",
    "    print(\"Invalid input. Coefficient 'a' cannot be zero for a quadratic equation.\")\n",
    "else: \n",
    "    result = find_roots(a, b, c)\n",
    "    print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4239c36f-aeb1-4d6f-a01e-829de37c7405",
   "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": 50,
   "id": "82bd3a45-3605-4f7d-b4a3-7adc6d3de400",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a year:  524\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "524 is not a century year.\n"
     ]
    }
   ],
   "source": [
    "def is_century_year(year):\n",
    "    \"\"\"\n",
    "    Check if the given year is a century year.\n",
    "    A century year is divisible by 100.\n",
    "    \"\"\"\n",
    "    if year % 100 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False \n",
    "year = int(input(\"Enter a year: \")) \n",
    "if is_century_year(year):\n",
    "    print(f\"{year} is a century year.\")\n",
    "else:\n",
    "    print(f\"{year} is not a century year.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8467049c-edae-4bc5-a7bc-c8878a1d7954",
   "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": 51,
   "id": "039939f4-06b3-429b-95e1-f1b0dc69f8a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  52\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52 is not a perfect square.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def is_perfect_square(number):\n",
    "    \"\"\"\n",
    "    Determine if a given number is a perfect square.\n",
    "    A number is a perfect square if its square root is an integer.\n",
    "    \"\"\"\n",
    "    if number < 0:\n",
    "        return False  \n",
    "     \n",
    "    root = int(math.sqrt(number))\n",
    "     \n",
    "    if root * root == number:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    " \n",
    "number = int(input(\"Enter a number: \")) \n",
    "if is_perfect_square(number):\n",
    "    print(f\"{number} is a perfect square.\")\n",
    "else:\n",
    "    print(f\"{number} is not a perfect square.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5bd73c6-ade5-4b79-b269-735240a395a5",
   "metadata": {},
   "source": [
    "21. Explain the purpose of the \"continue\" and \"break\" statements within if-else loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a9888669-1b1d-4078-98f3-c6d15ec8d4d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        continue  \n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "559340e5-4e2c-458f-bbad-bf72bd68f188",
   "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": 54,
   "id": "8fca52d9-2a32-4484-ba34-6749f7fa8965",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your weight in kilograms:  552\n",
      "Enter your height in meters:  55\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your BMI is 0.18. You are classified as Underweight.\n"
     ]
    }
   ],
   "source": [
    "def calculate_bmi(weight, height):\n",
    "    \"\"\"\n",
    "    Calculate the BMI (Body Mass Index) based on weight and height.\n",
    "    \"\"\"\n",
    "    return weight / (height ** 2)\n",
    "\n",
    "def categorize_bmi(bmi):\n",
    "    \"\"\"\n",
    "    Categorize the BMI value into different weight categories.\n",
    "    \"\"\"\n",
    "    if bmi < 18.5:\n",
    "        return \"Underweight\"\n",
    "    elif 18.5 <= bmi < 24.9:\n",
    "        return \"Normal weight\"\n",
    "    elif 25 <= bmi < 29.9:\n",
    "        return \"Overweight\"\n",
    "    else:\n",
    "        return \"Obesity\"\n",
    " \n",
    "weight = float(input(\"Enter your weight in kilograms: \"))\n",
    "height = float(input(\"Enter your height in meters: \"))\n",
    " \n",
    "if height <= 0:\n",
    "    print(\"Invalid input. Height must be greater than zero.\")\n",
    "else: \n",
    "    bmi = calculate_bmi(weight, height) \n",
    "    category = categorize_bmi(bmi) \n",
    "    print(f\"Your BMI is {bmi:.2f}. You are classified as {category}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2803c490-7e75-406e-a656-c14bc9c93b14",
   "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": 55,
   "id": "66c97176-0ec1-47ad-82ff-a5ee41ec5ea0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "def is_even(number):\n",
    "    \"\"\"\n",
    "    Function to determine if a number is even.\n",
    "    \"\"\"\n",
    "    if number % 2 == 0:\n",
    "        return True  \n",
    "    else:\n",
    "        return False   \n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \n",
    "even_numbers = filter(is_even, numbers)\n",
    " \n",
    "print(list(even_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e086df2-0cbd-4b30-bc1e-2ab5a1cac324",
   "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": 56,
   "id": "7c824f64-03a3-4915-af9c-8f4f69872deb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 is not a prime number.\n"
     ]
    }
   ],
   "source": [
    "def is_prime(number):\n",
    "    \"\"\"\n",
    "    Determine if a given number is a prime number.\n",
    "    \"\"\"\n",
    "    if number <= 1:\n",
    "        return False  \n",
    "    elif number == 2:\n",
    "        return True   \n",
    "    elif number % 2 == 0:\n",
    "        return False  \n",
    "    else: \n",
    "        for i in range(3, int(number**0.5) + 1, 2):\n",
    "            if number % i == 0:\n",
    "                return False\n",
    "        return True \n",
    "number = int(input(\"Enter a number: \"))\n",
    " \n",
    "if is_prime(number):\n",
    "    print(f\"{number} is a prime number.\")\n",
    "else:\n",
    "    print(f\"{number} is not a prime number.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d376ce27-6485-4e64-85c9-3e3b2bd38a1f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e07bffcc-7d9c-402f-a6a9-663389000e1e",
   "metadata": {},
   "source": [
    "                                                     Map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e2f648-1d33-41fc-8b41-30d64a9fd354",
   "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": "code",
   "execution_count": 57,
   "id": "ee6ae67b-9fe0-4631-8a45-2a0fe1594da4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square(number):\n",
    "    return number * number\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "squared_numbers = map(square, numbers)\n",
    " \n",
    "print(list(squared_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41b47af4-4bf9-4574-a33e-00a4583686c7",
   "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": 59,
   "id": "a2750aa7-54a2-4dc7-80b3-138bfb9cb93d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numbers: [1, 2, 3, 4, 5]\n",
      "Squared numbers: [1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square(number):\n",
    "    return number * number\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "squared_numbers = map(square, numbers)\n",
    " \n",
    "print(\"Original numbers:\", numbers)\n",
    "print(\"Squared numbers:\", list(squared_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60703e0c-8325-423b-ae36-0b939716590c",
   "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": 60,
   "id": "cb0e2c3d-750a-4e96-bd7e-7281514fbfb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square(number):\n",
    "    return number * number \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "squared_numbers = map(square, numbers) \n",
    "print(list(squared_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c36a59a7-ac99-496e-9bf0-75bc2b2a484b",
   "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": 61,
   "id": "f30a138e-202f-41aa-a7db-5a0e33be5c08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original names: ['Alice', 'Bob', 'Charlie', 'Diana']\n",
      "Uppercase names: ['ALICE', 'BOB', 'CHARLIE', 'DIANA']\n"
     ]
    }
   ],
   "source": [
    "def to_uppercase(name):\n",
    "    return name.upper() \n",
    "names = [\"Alice\", \"Bob\", \"Charlie\", \"Diana\"]\n",
    " \n",
    "uppercase_names = map(to_uppercase, names)\n",
    " \n",
    "print(\"Original names:\", names)\n",
    "print(\"Uppercase names:\", list(uppercase_names))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7896d591-bac2-4655-9afb-6bdab4b7eb96",
   "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": 62,
   "id": "b4767d57-b47c-4439-9b51-84f53eda348c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of words: ['apple', 'banana', 'cherry', 'date']\n",
      "Length of each word: [5, 6, 6, 4]\n"
     ]
    }
   ],
   "source": [
    "def get_length(word):\n",
    "    return len(word) \n",
    "words = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
    " \n",
    "lengths = map(get_length, words)\n",
    " \n",
    "print(\"List of words:\", words)\n",
    "print(\"Length of each word:\", list(lengths))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3c4350-1d6c-4f14-81a0-bdd4d491eab8",
   "metadata": {},
   "source": [
    "6. How can you use the `map()` function to apply a custom function to elements of multiple lists simultaneously in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "03f33643-830b-4204-aaec-40dd22215b7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1: [1, 2, 3, 4]\n",
      "List 2: [5, 6, 7, 8]\n",
      "Sums: [6, 8, 10, 12]\n"
     ]
    }
   ],
   "source": [
    "def add_elements(x, y):\n",
    "    return x + y \n",
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [5, 6, 7, 8] \n",
    "sums = map(add_elements, list1, list2) \n",
    "print(\"List 1:\", list1)\n",
    "print(\"List 2:\", list2)\n",
    "print(\"Sums:\", list(sums))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da4fdab-67a9-4a4e-8e43-ffd2475136b3",
   "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": 64,
   "id": "208078a4-5b1a-4a79-a730-a5d7bfafb266",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celsius temperatures: [0, 10, 20, 30, 40, 100]\n",
      "Fahrenheit temperatures: [32.0, 50.0, 68.0, 86.0, 104.0, 212.0]\n"
     ]
    }
   ],
   "source": [
    "def celsius_to_fahrenheit(celsius):\n",
    "    return (celsius * 9/5) + 32 \n",
    "celsius_temperatures = [0, 10, 20, 30, 40, 100]\n",
    " \n",
    "fahrenheit_temperatures = map(celsius_to_fahrenheit, celsius_temperatures) \n",
    "print(\"Celsius temperatures:\", celsius_temperatures)\n",
    "print(\"Fahrenheit temperatures:\", list(fahrenheit_temperatures))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19732c03-9cd6-4290-80a1-c6fd7d291aa4",
   "metadata": {},
   "source": [
    "8. Write a Python program that uses the `map()` function to round each element of a list of floating-point numbers to the nearest integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "135bf69f-2b99-4c8a-9f2d-f4aed41d3f6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original float numbers: [1.2, 2.5, 3.7, 4.8, 5.1, 6.9]\n",
      "Rounded numbers: [1, 2, 4, 5, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "def round_to_nearest_integer(number):\n",
    "    return round(number) \n",
    "float_numbers = [1.2, 2.5, 3.7, 4.8, 5.1, 6.9] \n",
    "rounded_numbers = map(round_to_nearest_integer, float_numbers) \n",
    "print(\"Original float numbers:\", float_numbers)\n",
    "print(\"Rounded numbers:\", list(rounded_numbers))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68605867-2cb8-4f1d-8922-d6dc0939b01e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "153bc9c5-ee9f-4478-8dd0-c495dc9b97da",
   "metadata": {},
   "source": [
    "                                                    Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5a1315d-2305-489c-9752-e49d652be10c",
   "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": 66,
   "id": "ae08c61d-2857-488f-a2ac-bcb3413368e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers: [1, 2, 3, 4, 5]\n",
      "Product of all numbers: 120\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def multiply(x, y):\n",
    "    return x * y \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "product = reduce(multiply, numbers)\n",
    "print(\"Numbers:\", numbers)\n",
    "print(\"Product of all numbers:\", product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60acb18-fe42-4d55-8835-41e5a343118b",
   "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": 68,
   "id": "3b49c4f1-8b04-4782-ad49-1b1ebf7248a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of numbers: [1, 2, 3, 4, 5]\n",
      "Product of all elements: 120\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def multiply(x, y):\n",
    "    return x * y \n",
    "numbers = [1, 2, 3, 4, 5] \n",
    "product = reduce(multiply, numbers) \n",
    "print(\"List of numbers:\", numbers)\n",
    "print(\"Product of all elements:\", product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e559a1f9-2513-47d3-b87b-88fd722ec685",
   "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": 69,
   "id": "5cd3b30a-9e60-4752-8d92-6df4be494ca5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of numbers: [10, 34, 56, 23, 78, 90, 12]\n",
      "Maximum element: 90\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def find_max(x, y):\n",
    "    return x if x > y else y \n",
    "numbers = [10, 34, 56, 23, 78, 90, 12]\n",
    " \n",
    "max_element = reduce(find_max, numbers) \n",
    "print(\"List of numbers:\", numbers)\n",
    "print(\"Maximum element:\", max_element)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f933cf6-e0c9-44e0-8eac-1a10362de2aa",
   "metadata": {},
   "source": [
    "4. How can you use the `reduce()` function to concatenate a list of strings into a single string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "440257f0-d360-4e68-acc3-659a038f9e2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of strings: ['Hello', ' ', 'world', '!', ' How', ' are', ' you?']\n",
      "Concatenated string: Hello world! How are you?\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def concatenate(str1, str2):\n",
    "    return str1 + str2 \n",
    "string_list = [\"Hello\", \" \", \"world\", \"!\", \" How\", \" are\", \" you?\"] \n",
    "result = reduce(concatenate, string_list) \n",
    "print(\"List of strings:\", string_list)\n",
    "print(\"Concatenated string:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8538a5ec-227f-4a25-b9ee-b5301229b42e",
   "metadata": {},
   "source": [
    "5. Write a Python program that calculates the factorial of a number using the `reduce()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9ace47c6-706b-4075-b0c4-59b00aaf1346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def multiply(x, y):\n",
    "    return x * y \n",
    "def factorial(n): \n",
    "    numbers = list(range(1, n + 1)) \n",
    "    return reduce(multiply, numbers)\n",
    " \n",
    "number = 5\n",
    " \n",
    "result = factorial(number) \n",
    "print(f\"The factorial of {number} is {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b6278cc-4cdc-4ac9-90e6-d07e4401ce55",
   "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": 72,
   "id": "3409120d-b9e1-4028-877c-5bba1da58448",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of numbers: [48, 72, 120, 144]\n",
      "GCD of the list: 24\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "import math \n",
    "def gcd(x, y):\n",
    "    return math.gcd(x, y) \n",
    "def find_gcd_of_list(numbers):\n",
    "    return reduce(gcd, numbers) \n",
    "numbers = [48, 72, 120, 144] \n",
    "result = find_gcd_of_list(numbers) \n",
    "print(\"List of numbers:\", numbers)\n",
    "print(\"GCD of the list:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8158d7cc-0f2c-4318-b47d-8fe157a997f6",
   "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": 73,
   "id": "a655e7c2-b39c-44ae-a2c8-b96bda8f6b94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the digits of 12345 is 15\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce \n",
    "def add_digits(x, y):\n",
    "    return x + y \n",
    "def sum_of_digits(number): \n",
    "    digits = [int(digit) for digit in str(number)]\n",
    "   \n",
    "    return reduce(add_digits, digits)\n",
    " \n",
    "number = 12345\n",
    " \n",
    "result = sum_of_digits(number)\n",
    " \n",
    "print(f\"The sum of the digits of {number} is {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c77e9bea-c910-4254-bad8-3634ff83492d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f416efc7-3087-433a-8f42-347019ee83c5",
   "metadata": {},
   "source": [
    "                                                           Filter "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42f54435-a90a-40ff-bb27-6d1a48d76da5",
   "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": 74,
   "id": "1bcd9de6-09cc-4f06-b059-7c7d56de8f05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Even numbers: [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    " def is_even(number):\n",
    "    return number % 2 == 0\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    " \n",
    "even_numbers = filter(is_even, numbers)\n",
    " \n",
    "print(\"Original list:\", numbers)\n",
    "print(\"Even numbers:\", list(even_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8f2aa9-e2da-4201-89a6-ef26ef7c45f1",
   "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": 2,
   "id": "8a589e1a-3e99-4996-91fe-8f92f43ff260",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Even numbers: [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def is_even(number):\n",
    "    return number % 2 == 0 \n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \n",
    "even_numbers = filter(is_even, numbers) \n",
    "print(\"Original list:\", numbers)\n",
    "print(\"Even numbers:\", list(even_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de60447-fde2-424b-9202-eb90ebc5b3d9",
   "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": "ed73dcba-9aa1-4c58-8784-0ea27d3c5e4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of names: ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace']\n",
      "Names starting with 'A': ['Alice']\n"
     ]
    }
   ],
   "source": [
    "def starts_with_letter(name, letter):\n",
    "    return name.startswith(letter) \n",
    "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\", \"Frank\", \"Grace\"] \n",
    "specific_letter = \"A\" \n",
    "filtered_names = filter(lambda name: starts_with_letter(name, specific_letter), names) \n",
    "print(\"Original list of names:\", names)\n",
    "print(f\"Names starting with '{specific_letter}':\", list(filtered_names))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d67304d-3d88-47aa-bed4-ba65e17d338b",
   "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": 6,
   "id": "e0f01d4b-83bc-4bad-b3e2-ff72ac1c1d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of numbers: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
      "Prime numbers: [2, 3, 5, 7, 11, 13, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "import math \n",
    "def is_prime(number):\n",
    "    if number <= 1:\n",
    "        return False\n",
    "    for i in range(2, int(math.sqrt(number)) + 1):\n",
    "        if number % i == 0:\n",
    "            return False\n",
    "    return True \n",
    "numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] \n",
    "prime_numbers = filter(is_prime, numbers) \n",
    "print(\"Original list of numbers:\", numbers)\n",
    "print(\"Prime numbers:\", list(prime_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dc5d3fa-224f-45fe-ad8a-23660ad67dbd",
   "metadata": {},
   "source": [
    "5. How can you use the `filter()` function to remove None values from a list in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "50fb942f-3e1e-451a-a844-77e59e554767",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of numbers: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
      "Prime numbers: [2, 3, 5, 7, 11, 13, 17, 19]\n"
     ]
    }
   ],
   "source": [
    " import math\n",
    "def is_prime(number):\n",
    "    if number <= 1:\n",
    "        return False\n",
    "    for i in range(2, int(math.sqrt(number)) + 1):\n",
    "        if number % i == 0:\n",
    "            return False\n",
    "    return True\n",
    " \n",
    "numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    " \n",
    "prime_numbers = filter(is_prime, numbers)\n",
    "\n",
    "print(\"Original list of numbers:\", numbers)\n",
    "print(\"Prime numbers:\", list(prime_numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ef5244c-fc55-43cd-9b4e-fa81fa8c2d30",
   "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": 2,
   "id": "6970c702-9e8f-44f6-8b72-7878d0dfd81e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of names: ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace']\n",
      "Names starting with 'A': ['Alice']\n"
     ]
    }
   ],
   "source": [
    "def starts_with_letter(name, letter):\n",
    "    return name.startswith(letter) \n",
    "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\", \"Frank\", \"Grace\"] \n",
    "specific_letter = \"A\" \n",
    "filtered_names = filter(lambda name: starts_with_letter(name, specific_letter), names) \n",
    "print(\"Original list of names:\", names)\n",
    "print(f\"Names starting with '{specific_letter}':\", list(filtered_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c66dbf4-5590-49a8-9d73-eaa5e130f8e5",
   "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": 3,
   "id": "9f0488ed-b239-455e-8a9e-d05fc9f25395",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of values: [10, 23, 5, 67, 34, 2, 89, 45, 22, 10]\n",
      "Values greater than 20: [23, 67, 34, 89, 45, 22]\n"
     ]
    }
   ],
   "source": [
    "def is_greater_than_threshold(value, threshold):\n",
    "    return value > threshold \n",
    "values = [10, 23, 5, 67, 34, 2, 89, 45, 22, 10] \n",
    "threshold = 20 \n",
    "\n",
    "filtered_values = filter(lambda value: is_greater_than_threshold(value, threshold), values)\n",
    " \n",
    "print(\"Original list of values:\", values)\n",
    "print(f\"Values greater than {threshold}:\", list(filtered_values))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9df0c4b-586e-4143-871e-0a6ba8ab927a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "350cd158-2a81-483d-8fd3-73efe8d51985",
   "metadata": {},
   "source": [
    "                                                       Recursion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75c3a1f5-4e1a-4e6f-9284-f8d74e78c634",
   "metadata": {},
   "source": [
    "1. Explain the concept of recursion in Python. How does it differ from iteration?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f31463bd-a2e1-427a-960a-bda3ba752393",
   "metadata": {},
   "source": [
    "Recursion and iteration are two fundamental approaches to solving problems in programming. Both are used to repeat a block of code, but they do so in different ways.\n",
    "\n",
    "Recursion\n",
    "Recursion is a technique where a function calls itself in order to solve a problem. The function breaks the problem down into smaller sub-problems until it reaches a base case, which stops the recursion.\n",
    "\n",
    "Key Components of Recursion:\n",
    "Base Case: The condition under which the recursion stops. Without a base case, the function would call itself indefinitely, leading to a stack overflow.\n",
    "Recursive Case: The part of the function that reduces the problem and calls the function itself with the smaller problem."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ef2b5c-da0c-4fbe-b513-0ecd9828d3ac",
   "metadata": {},
   "source": [
    "2. Write a Python program to calculate the factorial of a number using recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c375a2fc-96dd-4163-8ed6-6acb7213fc2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n): \n",
    "    if n == 0:\n",
    "        return 1 \n",
    "    else:\n",
    "        return n * factorial(n - 1)\n",
    " \n",
    "number = 5\n",
    "print(f\"The factorial of {number} is {factorial(number)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c565e72-53d0-49a8-8958-5094d88a0e7f",
   "metadata": {},
   "source": [
    "3. Create a recursive Python function to find the nth Fibonacci number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "608e3c6d-c75f-4a15-841f-517e9f23ecc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n): \n",
    "    if n == 0:\n",
    "        return 1 \n",
    "    else:\n",
    "        return n * factorial(n - 1)\n",
    " \n",
    "number = 5\n",
    "print(f\"The factorial of {number} is {factorial(number)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc46ca1c-5107-4c5d-a189-90f7712c246b",
   "metadata": {},
   "source": [
    "4. Write a recursive Python function to calculate the sum of all elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6605fca6-102f-4a23-8fd5-e319308f30fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the list [1, 2, 3, 4, 5] is 15\n"
     ]
    }
   ],
   "source": [
    "def sum_list(lst): \n",
    "    if len(lst) == 0:\n",
    "        return 0 \n",
    "    else:\n",
    "        return lst[0] + sum_list(lst[1:])\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(f\"The sum of the list {numbers} is {sum_list(numbers)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f378f51f-1868-4d38-ac14-f76d0c99262e",
   "metadata": {},
   "source": [
    "5. How can you prevent a recursive function from running indefinitely, causing a stack overflow "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "65a4efab-f8ce-4c82-9d72-f475e4fc1b7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    " def factorial(n):\n",
    "    if n == 0:   \n",
    "        return 1\n",
    "    elif n > 0:  \n",
    "        return n * factorial(n - 1)\n",
    "    else:\n",
    "        raise ValueError(\"Factorial is not defined for negative numbers\")\n",
    " \n",
    "print(factorial(5)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b6b7a4c-5614-4b6b-b91d-56160b941f5d",
   "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": 8,
   "id": "2418cfee-c3bd-47d5-92db-5e91f0bf5834",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The GCD of 48 and 18 is 6\n"
     ]
    }
   ],
   "source": [
    "def gcd(a, b): \n",
    "    if b == 0:\n",
    "        return a \n",
    "    else:\n",
    "        return gcd(b, a % b)\n",
    " \n",
    "num1 = 48\n",
    "num2 = 18\n",
    "print(f\"The GCD of {num1} and {num2} is {gcd(num1, num2)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10fd246b-c76d-42de-b3f5-ed1fcbfe3259",
   "metadata": {},
   "source": [
    "7. Write a recursive Python function to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d37161f5-ce80-486f-907a-953765f5cbcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The reverse of 'hello' is 'olleh'\n"
     ]
    }
   ],
   "source": [
    "def reverse_string(s): \n",
    "    if len(s) <= 1:\n",
    "        return s \n",
    "    else:\n",
    "        return reverse_string(s[1:]) + s[0]\n",
    " \n",
    "input_string = \"hello\"\n",
    "print(f\"The reverse of '{input_string}' is '{reverse_string(input_string)}'\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fd731c0-7433-4589-9628-ff8e22661d9f",
   "metadata": {},
   "source": [
    "8. Create a recursive Python function to calculate the power of a number (x^n)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "55b908d6-0332-4bc9-b535-cd97288c6db3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the list [1, 2, 3, 4, 5] is 15\n"
     ]
    }
   ],
   "source": [
    "def sum_list(lst): \n",
    "    if len(lst) == 0:\n",
    "        return 0 \n",
    "    else:\n",
    "        return lst[0] + sum_list(lst[1:])\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(f\"The sum of the list {numbers} is {sum_list(numbers)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b381cf-6472-4cc9-bfdd-a65af82fc59a",
   "metadata": {},
   "source": [
    "9. Write a recursive Python function to find all permutations of a given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cfa3f9cf-01d7-4e69-adc1-d4555c228c83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All permutations of 'abc' are: ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n"
     ]
    }
   ],
   "source": [
    "def permutations(s): \n",
    "    if len(s) <= 1:\n",
    "        return [s]\n",
    "     \n",
    "    perm_list = []\n",
    "     \n",
    "    for i in range(len(s)): \n",
    "        char = s[i]\n",
    "         \n",
    "        remaining_chars = s[:i] + s[i+1:]\n",
    "         \n",
    "        for perm in permutations(remaining_chars):\n",
    "            perm_list.append(char + perm)\n",
    "    \n",
    "    return perm_list\n",
    " \n",
    "input_string = \"abc\"\n",
    "print(f\"All permutations of '{input_string}' are: {permutations(input_string)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02e3495c-832d-4ea7-9d0e-81c7cd4e7bd3",
   "metadata": {},
   "source": [
    "10. Write a recursive Python function to check if a string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "49794d2d-8b6e-488c-a9c5-40303226f906",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is 'radar' a palindrome? True\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(s): \n",
    "    if len(s) <= 1:\n",
    "        return True\n",
    "     \n",
    "    if s[0] == s[-1]: \n",
    "        return is_palindrome(s[1:-1])\n",
    "    else:\n",
    "        return False \n",
    "test_string = \"radar\"\n",
    "print(f\"Is '{test_string}' a palindrome? {is_palindrome(test_string)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1652ac37-ef88-4508-8f45-2eee53c7b8a0",
   "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": "4b2485bd-37a2-438d-a2d2-7cc35b8977ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All combinations of [1, 2, 3] are: [[], [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "def combinations(lst): \n",
    "    if not lst:\n",
    "        return [[]]\n",
    "     \n",
    "    first = lst[0] \n",
    "    rest_combinations = combinations(lst[1:])\n",
    "     \n",
    "    with_first = [ [first] + comb for comb in rest_combinations ]\n",
    "     \n",
    "    return rest_combinations + with_first\n",
    " \n",
    "elements = [1, 2, 3]\n",
    "print(f\"All combinations of {elements} are: {combinations(elements)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a31b9cf0-fd90-48eb-991c-5ea1f530fc3d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7d76bbc7-944a-4aa4-85e3-c652cbc185e3",
   "metadata": {},
   "source": [
    "                                               Basics of Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb7db069-247b-496a-b5eb-33a7fd2eaf31",
   "metadata": {},
   "source": [
    "1. What is a function in Python, and why is it used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61dc6081-ab5f-49f4-b054-e2ecf0d72b86",
   "metadata": {},
   "source": [
    "A function in Python is a reusable block of code that performs a specific task. It can take inputs (arguments), execute a series of statements, and return an output (result). Functions help to modularize code, making it more readable, maintainable, and reusable.\n",
    "\n",
    "Use  of Functions\n",
    "\n",
    "Modularity:\n",
    "\n",
    "Functions allow you to break down complex problems into smaller, more manageable parts. Each function can perform a specific task, making the code easier to understand and manage.\n",
    "\n",
    "Reusability:\n",
    "\n",
    "Once a function is defined, it can be reused multiple times in different parts of the program, reducing redundancy and making code maintenance easier.\n",
    "\n",
    "Readability: \n",
    "\n",
    "Functions can make the code more readable by providing a clear structure. The name of a function can describe what the function does, which helps others understand the code more easily.\n",
    "\n",
    "Maintainability:\n",
    "\n",
    "Functions make it easier to update and maintain code. Changes in functionality can be made in one place (the function definition), rather than having to update the same logic multiple times throughout the code.\n",
    "\n",
    "Abstraction: \n",
    "\n",
    "Functions allow you to abstract away complex logic. Users of the function don’t need to understand its internal workings; they only need to know how to use it.\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3890ec-77da-4491-9fc5-adbc9508837a",
   "metadata": {},
   "source": [
    "2. How do you define a function in Python? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4723ed51-7525-4b3c-96cb-6d67b7707e3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Amit!\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    \"\"\"\n",
    "    This function greets the person whose name is passed as a parameter.\n",
    "    \"\"\"\n",
    "    print(f\"Hello, {name}!\") \n",
    "greet(\"Amit\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9122fa91-a6a6-46a5-9720-191724e1146b",
   "metadata": {},
   "source": [
    "3. Explain the difference between a function definition and a function call."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb7515d-978a-4390-842a-2acb05f3ee1a",
   "metadata": {},
   "source": [
    "Function Definition\n",
    "\n",
    "A function definition is the code that specifies what a function does. It includes the function's name, parameters, and the block of code that runs when the function is called. The function is defined using the def keyword.\n",
    "\n",
    "Function Call\n",
    "\n",
    "A function call is the code that runs the function defined earlier. It involves writing the function's name followed by parentheses, possibly with arguments inside the parentheses if the function requires them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1926910-f130-4f83-8d33-2e828fc2efe3",
   "metadata": {},
   "source": [
    "4. Write a Python program that defines a function to calculate the sum of two numbers and then\n",
    "calls the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74e25401-769a-4add-a247-d792f6d6333d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 5 and 3 is: 8\n"
     ]
    }
   ],
   "source": [
    "def sum_of_two_numbers(a, b):\n",
    "    \"\"\"\n",
    "    This function returns the sum of two numbers a and b.\n",
    "    \"\"\"\n",
    "    return a + b\n",
    " \n",
    "result = sum_of_two_numbers(5, 3) \n",
    "print(f\"The sum of 5 and 3 is: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3a63bad-c8e2-45fd-b350-9644a743d8a0",
   "metadata": {},
   "source": [
    "5. What is a function signature, and what information does it typically include?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556053d6-6d8a-498c-adec-a49d5db1b20c",
   "metadata": {},
   "source": [
    "A function signature in Python refers to the part of the function definition that includes the function's name and its parameter list. The function signature provides essential information about how the function can be called and what arguments it expects.\n",
    "\n",
    "Components of a Function Signature\n",
    "\n",
    "1.- Function Name: This is the identifier used to call the function.          \n",
    "2.- Parameters: These are the variables listed inside the parentheses following the function name. Parameters define what arguments the function expects when it is called."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f26041f-5dd9-421b-bfde-7dbbed04a186",
   "metadata": {},
   "source": [
    "6. Create a Python function that takes two arguments and returns their product."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df67f771-dcfa-4644-9381-61d077e9dd5c",
   "metadata": {},
   "source": [
    "def product_of_two_numbers(a, b):\n",
    "    \"\"\"\n",
    "    This function returns the product of two numbers a and b.\n",
    "    \"\"\"\n",
    "    return a * b\n",
    " \n",
    "result = product_of_two_numbers(4, 5) \n",
    "print(f\"The product of 4 and 5 is: {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3ac84fd-8aaa-4b3a-a994-73a0367240a8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "15074a21-bda3-45d5-abf2-b7504f85ab99",
   "metadata": {},
   "source": [
    "                                   Function Parameters and Arguments:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2918c89-6657-49c5-a642-d40440a3dcdc",
   "metadata": {},
   "source": [
    "1. Explain the concepts of formal parameters and actual arguments in Python functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac32b6ca-1660-4430-9d0e-f983d57b349c",
   "metadata": {},
   "source": [
    "Formal Parameters\n",
    "\n",
    "Formal parameters (or formal arguments) are the variables defined in a function's signature. They act as placeholders for the values that will be passed to the function when it is called. Formal parameters are used within the function to refer to the input data.\n",
    "\n",
    "Actual Arguments\n",
    "Actual arguments (or actual parameters) are the real values or variables passed to the function when it is called. These arguments are used to provide input data to the function's formal parameters.\n",
    "\n",
    "Relationship Between Formal Parameters and Actual Arguments\n",
    "\n",
    "When a function is called, each actual argument is assigned to the corresponding formal parameter. This process allows the function to operate on the provided data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcc671ea-3e87-455b-bc03-1f5fd724d084",
   "metadata": {},
   "source": [
    "2. Write a Python program that defines a function with default argument values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "08069965-de76-4f83-9222-f28c3d87ffd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Guest! Welcome!\n",
      "Hello, Alice! Welcome!\n",
      "Hello, Bob! Good to see you!\n"
     ]
    }
   ],
   "source": [
    "def greet(name=\"Guest\", message=\"Welcome!\"):\n",
    "    \"\"\"\n",
    "    This function prints a greeting message.\n",
    "    If no arguments are provided, it uses the default values.\n",
    "    \"\"\"\n",
    "    print(f\"Hello, {name}! {message}\")\n",
    " \n",
    "greet()\n",
    " \n",
    "greet(\"Alice\")\n",
    " \n",
    "greet(\"Bob\", \"Good to see you!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b5c111f-6e36-419e-bee1-ccecc45d67eb",
   "metadata": {},
   "source": [
    "3. How do you use keyword arguments in Python function calls? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a299fd50-e274-4238-9d92-0cbdd07348aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is John Doe and I am 30 years old.\n",
      "My name is Jane Smith and I am 25 years old.\n"
     ]
    }
   ],
   "source": [
    "def introduce(first_name, last_name, age):\n",
    "    \"\"\"\n",
    "    This function prints an introduction message.\n",
    "    \"\"\"\n",
    "    print(f\"My name is {first_name} {last_name} and I am {age} years old.\") \n",
    "introduce(first_name=\"John\", last_name=\"Doe\", age=30)\n",
    " \n",
    "introduce(age=25, last_name=\"Smith\", first_name=\"Jane\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87e60e24-199d-4d50-8dfc-bc2a95df69be",
   "metadata": {},
   "source": [
    "4. Create a Python function that accepts a variable number of arguments and calculates their sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9cfd7113-fcdb-48e6-8b15-769fa381674d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "9\n",
      "100\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def sum_of_numbers(*args):\n",
    "    \"\"\"\n",
    "    This function returns the sum of a variable number of arguments.\n",
    "    \"\"\"\n",
    "    return sum(args)\n",
    " \n",
    "print(sum_of_numbers(1, 2, 3))         \n",
    "print(sum_of_numbers(4, 5))             \n",
    "print(sum_of_numbers(10, 20, 30, 40))  \n",
    "print(sum_of_numbers())                \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46fa5b2d-080b-466e-9f2b-a86920ec31f2",
   "metadata": {},
   "source": [
    "5. What is the purpose of the `*args` and `**kwargs` syntax in function parameter lists?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a71ad760-8b2d-4067-a43d-47b1bd14fa04",
   "metadata": {},
   "source": [
    " The *args and **kwargs syntax in Python function parameter lists allows for more flexible function definitions that can accept a variable number of arguments.\n",
    "\n",
    "*args\n",
    "\n",
    "Purpose: Allows a function to accept any number of positional arguments.\n",
    "How It Works: Inside the function, args is treated as a tuple containing all the positional arguments passed to the function.\n",
    "Use Case: When you don't know beforehand how many positional arguments might be passed to your function.\n",
    "\n",
    "**kwargs\n",
    "\n",
    "Purpose: Allows a function to accept any number of keyword arguments.\n",
    "How It Works: Inside the function, kwargs is treated as a dictionary containing all the keyword arguments passed to the function.\n",
    "Use Case: When you want to allow the function to handle named arguments that you don't know beforehand."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98366b27-8dab-4534-84c4-8bd343cee5c0",
   "metadata": {},
   "source": [
    "                                            Return Values and Scoping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e2c2e7-1f4b-4138-ae75-98309891d35e",
   "metadata": {},
   "source": [
    "1. Describe the role of the `return` statement in Python functions and provide examples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc34cdc1-cf43-4998-9e85-a49ffdac075a",
   "metadata": {},
   "source": [
    "The return statement in Python functions plays a crucial role in controlling the flow of a function and specifying the output. It allows a function to send a result back to the caller and exit the function's scope.\n",
    "\n",
    "Roles of the return Statement\n",
    "Returning a Value: The return statement can return a value from a function to the caller. This value can then be used in expressions or assigned to variables.\n",
    "Exiting the Function: Once a return statement is executed, the function terminates immediately, and no further code within that function is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "aa634520-4781-4f94-8de3-d87bc51e5361",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "result = add(3, 5)\n",
    "print(result)   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4531726a-d627-4b80-b0fc-e1e2072d7a72",
   "metadata": {},
   "source": [
    "2. Explain the concept of variable scope in Python, including local and global variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df090dbf-44b1-408f-b32e-278266c2c189",
   "metadata": {},
   "source": [
    "\n",
    "Variable scope in Python determines where a variable can be accessed or modified within the code. Python has two primary types of variable scope: local and global.\n",
    "\n",
    "Local Variables\n",
    "\n",
    "Local Variables: These are variables defined within a function or block of code. Their scope is limited to the function or block in which they are defined. They cannot be accessed outside of that function or block.\n",
    "\n",
    "Global Variables\n",
    "\n",
    "Global Variables: These are variables defined outside of any function or block. Their scope extends to the entire script or module in which they are defined. They can be accessed and modified from any function within the same module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b17f4aa-e124-49f3-9c52-855fd88c5e14",
   "metadata": {},
   "source": [
    "3 Write a Python program that demonstrates the use of global variables within functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6afff088-58c8-4541-89e4-3542093ab1c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter incremented to: 1\n",
      "Counter incremented to: 2\n",
      "Current counter value: 2\n",
      "Counter has been reset.\n",
      "Current counter value: 0\n"
     ]
    }
   ],
   "source": [
    " \n",
    "counter = 0\n",
    "\n",
    "def increment():\n",
    "    global counter   \n",
    "    counter += 1\n",
    "    print(f\"Counter incremented to: {counter}\")\n",
    "\n",
    "def reset():\n",
    "    global counter  \n",
    "    counter = 0\n",
    "    print(\"Counter has been reset.\")\n",
    "\n",
    "def display():\n",
    "    print(f\"Current counter value: {counter}\")\n",
    " \n",
    "increment()   \n",
    "increment()    \n",
    "display()      \n",
    "reset()        \n",
    "display()     \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ca14dd-2c1e-4d35-85e6-b34888d87680",
   "metadata": {},
   "source": [
    "4. Create a Python function that calculates the factorial of a number and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e9bb6048-aec7-40ca-ae86-ba730942be80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    \"\"\"\n",
    "    Calculate the factorial of a non-negative integer n using an iterative approach.\n",
    "    \n",
    "    Parameters:\n",
    "    n (int): A non-negative integer whose factorial is to be computed.\n",
    "\n",
    "    Returns:\n",
    "    int: The factorial of the number n.\n",
    "    \"\"\"\n",
    "    if n < 0:\n",
    "        raise ValueError(\"Factorial is not defined for negative numbers\")\n",
    "    result = 1\n",
    "    for i in range(2, n + 1):\n",
    "        result *= i\n",
    "    return result\n",
    " \n",
    "print(factorial(5))   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b4a239-d46f-4859-89ce-7422e6737306",
   "metadata": {},
   "source": [
    "5. How can you access variables defined outside a function from within the function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4a666e66-b547-4a38-bfda-c444d465d078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# Global variable\n",
    "message = \"Hello, World!\"\n",
    "\n",
    "def print_message():\n",
    "    # Accessing the global variable\n",
    "    print(message)\n",
    "\n",
    "print_message()  # Output: Hello, World!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1f3b54-7431-43f6-9ea0-55bab5674569",
   "metadata": {},
   "source": [
    "                                    Lambda Functions and Higher-Order Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27b0230-5ffa-4caa-94b6-3068d940265d",
   "metadata": {},
   "source": [
    "1. What are lambda functions in Python, and when are they typically used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "037fe6ba-8944-4088-bf81-2e0424f69571",
   "metadata": {},
   "source": [
    "Lambda functions in Python, also known as anonymous functions, are small, unnamed functions defined with the lambda keyword. They can have any number of input parameters but only a single expression, which is evaluated and returned. Lambda functions are typically used for short, throwaway functions that are not reused elsewhere in the code.\n",
    "\n",
    "Uses of Lambda Functions.\n",
    "\n",
    "1- Sorting and Filtering: Commonly used as key functions in sorting and filtering operations.    \n",
    "2- Functional Programming: Used with functions like map(), filter(), and reduce() for concise and readable code.      \n",
    "3 Callbacks: Useful for short callback functions.      \n",
    "4-Inline Functions: When a small function is needed for a short period of time and does not warrant a full function definition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e044e7d-4fb4-45f5-8d42-dc32080d3c48",
   "metadata": {},
   "source": [
    "2. Write a Python program that uses lambda functions to sort a list of tuples based on the second\n",
    "element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5395b8e8-d001-42fc-9528-c300e0b066c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list based on the second element: [(4, 1), (5, 2), (1, 3), (2, 4)]\n"
     ]
    }
   ],
   "source": [
    " \n",
    "tuples_list = [(1, 3), (4, 1), (5, 2), (2, 4)]\n",
    " \n",
    "sorted_list = sorted(tuples_list, key=lambda x: x[1])\n",
    " \n",
    "print(\"Sorted list based on the second element:\", sorted_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09e5e511-f88f-4b95-812f-f0976a252627",
   "metadata": {},
   "source": [
    "3.Explain the concept of higher-order functions in Python, and provide an example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49cd2b3e-1a9b-4e12-b683-81182b8284b9",
   "metadata": {},
   "source": [
    "A higher-order function is a function that either takes one or more functions as arguments, returns a function as its result, or both. This concept is central to functional programming and allows for the creation of more modular and reusable code.\n",
    "\n",
    "Key Characteristics of Higher-Order Functions\n",
    "\n",
    "1. Accepting Functions as Arguments: A higher-order function can take other functions as input parameters.\n",
    "2. Returning Functions as Output: A higher-order function can return a function as its result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7d381cda-eef5-4163-a976-40cd5a6237b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x * x\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = list(map(square, numbers))\n",
    "print(squared_numbers)  # Output: [1, 4, 9, 16, 25]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b03c69-ed9f-46e0-9789-c2bd0c34c0ab",
   "metadata": {},
   "source": [
    "4. Create a Python function that takes a list of numbers and a function as arguments, applying the\n",
    "function to each element in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a7dd9b2d-1660-422f-8413-34c9d2971736",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def apply_function_to_list(numbers, func):\n",
    "    \"\"\"\n",
    "    Applies a given function to each element in a list of numbers.\n",
    "\n",
    "    Parameters:\n",
    "    numbers (list): A list of numbers.\n",
    "    func (function): A function to apply to each element in the list.\n",
    "\n",
    "    Returns:\n",
    "    list: A new list with the function applied to each element.\n",
    "    \"\"\"\n",
    "    return [func(num) for num in numbers]\n",
    " \n",
    "def square(x):\n",
    "    return x * x\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = apply_function_to_list(numbers, square)\n",
    "print(squared_numbers)   \n",
    " \n",
    "incremented_numbers = apply_function_to_list(numbers, lambda x: x + 1)\n",
    "print(incremented_numbers) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ecfcf09-bdcd-4756-a280-9e008a70b1cd",
   "metadata": {},
   "source": [
    "                                                       Built-in Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1d9d83-484a-4e08-9c14-d71134a91202",
   "metadata": {},
   "source": [
    "1. Describe the role of built-in functions like `len()`, `max()`, and `min()` in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "598c7f0e-4b64-443d-807a-8b4db1bc474d",
   "metadata": {},
   "source": [
    "Built-in functions in Python, such as len(), max(), and min(), play crucial roles in simplifying common tasks and making code more readable and efficient. Here’s a detailed look at these functions:\n",
    "\n",
    "len()\n",
    "\n",
    "The len() function returns the number of items in an object. The object can be a sequence (such as a string, list, or tuple) or a collection (such as a dictionary or set)\n",
    "\n",
    "max()\n",
    "\n",
    "The max() function returns the largest item in an iterable or the largest of two or more arguments.\n",
    "\n",
    "min()\n",
    "\n",
    "The min() function returns the smallest item in an iterable or the smallest of two or more arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf37bf5-6b0b-4dbf-a52d-8c4c2b533864",
   "metadata": {},
   "source": [
    "2. Write a Python program that uses the `map()` function to apply a function to each element of a\n",
    "list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9d6859af-c960-4dbf-97ef-ceab2b3342fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numbers: [1, 2, 3, 4, 5]\n",
      "Squared numbers: [1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    \"\"\"Returns the square of a number.\"\"\"\n",
    "    return x * x\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "squared_numbers = list(map(square, numbers))\n",
    " \n",
    "print(\"Original numbers:\", numbers)\n",
    "print(\"Squared numbers:\", squared_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31f61e4f-6205-4eea-9155-4f4b75efee48",
   "metadata": {},
   "source": [
    "3. How does the `filter()` function work in Python, and when would you use it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca3cbc37-199e-44ca-95a8-ad1d18d87d61",
   "metadata": {},
   "source": [
    "\n",
    "The filter() function in Python is used to create an iterator that filters elements from an iterable (like a list, tuple, or string) based on a function that returns either True or False. Only the elements for which the function returns True are included in the resulting iterator.\n",
    "\n",
    "Syntax\n",
    " \n",
    "function: A function that tests each element of the iterable. It should return True for elements to keep and False for elements to discard.\n",
    "iterable: An iterable like a list, tuple, or string whose elements are to be filtered.\n",
    "\n",
    "When to Use filter()\n",
    "\n",
    "You would use filter() in scenarios where you need to select a subset of elements from an iterable based on a certain condition. This is particularly useful for:\n",
    "\n",
    "Removing unwanted elements: Filtering out elements that do not meet certain criteria.  \n",
    "Data cleaning: Removing invalid or undesired data from a dataset.  \n",
    "Functional programming: When you prefer using functional programming techniques to process collections of data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bde429be-3dba-4b0e-8fc5-95ffffe111dd",
   "metadata": {},
   "source": [
    "4. Create a Python program that uses the `reduce()` function to find the product of all elements in\n",
    "a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6073f957-243c-4d34-aec0-59c288f35bc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of all elements in the list is: 120\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    " \n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    " \n",
    "numbers = [1, 2, 3, 4, 5]\n",
    " \n",
    "product = reduce(multiply, numbers)\n",
    " \n",
    "print(\"The product of all elements in the list is:\", product)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9021f5d1-c67c-4097-bdca-df0659a3e5cc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "52636bf7-d592-4aba-b6f4-5ad9d614f540",
   "metadata": {},
   "source": [
    "                                            Function Documentation and Best Practices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5771f6bd-ba07-48d4-8a0b-63e351cba2e0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "83df0cfc-0a49-47cc-8a0f-a10280971012",
   "metadata": {},
   "source": [
    "1. Explain the purpose of docstrings in Python functions and how to write them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45a4b10f-c00f-4260-9eff-9aac4e67d598",
   "metadata": {},
   "source": [
    "Docstrings in Python are a way to document your functions, classes, modules, and methods. They provide a convenient way to describe what a piece of code does, its parameters, return values, and any other important details. Docstrings are essential for code readability and maintainability, especially in larger projects or when working with others.\n",
    "\n",
    "Purpose of Docstrings\n",
    "\n",
    "Documentation: Docstrings describe the purpose and functionality of functions, classes, and methods. They serve as an in-code reference for anyone reading or maintaining the code. \n",
    "\n",
    "Help and Reference: Tools like help() in Python can use docstrings to provide information about how to use functions and classes. \n",
    "\n",
    "Code Quality: They enhance the readability and usability of the code by providing context and explanations directly within the codebase. \n",
    "\n",
    "Consistency: They help maintain a consistent approach to documentation across the codebase. \n",
    "\n",
    "How to Write Docstrings\n",
    "\n",
    "Docstrings are written using triple quotes (\"\"\" or '''), and they should be placed immediately after the function, class, or method definition.\n",
    "\n",
    "Basic Syntax\n",
    "\n",
    "For functions, the docstring should include:\n",
    "\n",
    "1. A brief description of what the function does.\n",
    "2. A description of the parameters (arguments) and their types.\n",
    "3. The return value and its type.\n",
    "4. Any exceptions that the function may raise (optional)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4ae27a1-8426-4852-a28e-3efe0d8ae0e1",
   "metadata": {},
   "source": [
    "2. Describe some best practices for naming functions and variables in Python, including naming\n",
    "conventions and guidelines."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b3055e6-da08-4e79-a387-387bec599d95",
   "metadata": {},
   "source": [
    "Naming functions and variables effectively is crucial for writing readable and maintainable code. Here are some best practices and guidelines for naming functions and variables in Python:\n",
    "\n",
    "Naming Conventions and Guidelines\n",
    "\n",
    "General Guidelines\n",
    "\n",
    "1. Be Descriptive:\n",
    "\n",
    "Use names that clearly describe the purpose or functionality of the variable or function.\n",
    "Avoid single-letter names except for loop counters (e.g., i, j).\n",
    "\n",
    "2. Be Consistent:\n",
    "\n",
    "Follow a consistent naming style throughout your codebase. Consistency helps improve readability and maintainability.\n",
    "\n",
    "3. Use Meaningful Names:\n",
    "\n",
    "Choose names that convey the meaning or role of the variable or function. For example, use average_age instead of a.\n",
    "\n",
    "4. Avoid Abbreviations:\n",
    "\n",
    "Avoid abbreviations that are not commonly understood. If you use abbreviations, ensure they are clear and consistent.\n",
    "\n",
    "Function Naming\n",
    "\n",
    "1. Use Lowercase with Underscores:\n",
    " \n",
    "Function names should be in lowercase, with words separated by underscores (_) for readability. \n",
    "Example: calculate_total_price, get_user_input, sort_list\n",
    "\n",
    "2. Start with a Verb:\n",
    "\n",
    "Function names should typically start with a verb to indicate an action or behavior. \n",
    "Example: find_maximum, update_record, fetch_data\n",
    "\n",
    "3. Avoid Using Keywords:\n",
    "\n",
    "Avoid using Python reserved keywords (like class, if, def) as function names.\n",
    "\n",
    "4. Be Specific:\n",
    "\n",
    "Make function names specific to their task. For example, use parse_json_file instead of just parse.\n",
    "\n",
    " Variable Naming\n",
    " \n",
    "1. Use Lowercase with Underscores:\n",
    "\n",
    "Variable names should be in lowercase, with words separated by underscores for readability. \n",
    "\n",
    "Example: total_amount, user_name, is_active\n",
    "\n",
    "2. Use Descriptive Names:\n",
    "\n",
    "Use names that describe the content or purpose of the variable. \n",
    "\n",
    "Example: student_grades, max_temperature, email_address \n",
    "\n",
    "3. Avoid Single-Letter Names:\n",
    "\n",
    "Avoid single-letter names except for loop counters and variables in small scopes where context is clear. \n",
    "\n",
    "Example: i (for iteration), x (for temporary calculations) \n",
    "\n",
    "4. Use Consistent Naming for Constants:\n",
    "\n",
    "Constants should be written in uppercase with words separated by underscores.   \n",
    "\n",
    "Example: PI, MAX_RETRIES, DEFAULT_TIMEOUT\n",
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9946c37-a4d7-4c7f-9ffa-b0602c388971",
   "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
}