17th_Sept'23_Python_FUNCTIONS_Assignemnt.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "FOR LOOP"
      ],
      "metadata": {
        "id": "lSvowSJ0YFvF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Q1: Write a Python program to print numbers from 1 to 10 using a for loop.\n",
        "for i in range(1, 11):\n",
        "    print(i)"
      ],
      "metadata": {
        "id": "1Gt8PxfyDfSD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6110c761-43ea-400a-d3db-6fb4f517cccb"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q2: Explain the difference between a for loop and a while loop in Python.\n",
        "# A for loop is used for iterating over a sequence (that is either a list, tuple, dictionary, set, or string).\n",
        "# A while loop is used for executing a block of statements as long as a condition is true."
      ],
      "metadata": {
        "id": "yvLURyi6YfEP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Q3: Write a Python program to calculate the sum of all numbers from 1 to 100 using a for loop.\n",
        "total = 0\n",
        "for i in range(1, 101):\n",
        "    total += i\n",
        "print(\"Sum of numbers from 1 to 100:\", total)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qC8tVusCZG9n",
        "outputId": "871a4001-520f-4f83-e5fc-f1c96ee36975"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of numbers from 1 to 100: 5050\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q4: How do you iterate through a list using a for loop in Python?\n",
        "# You can iterate through a list using a for loop by using the \"for element in list\" syntax.\n",
        "# For example:\n",
        "my_list = [1, 2, 3, 4, 5]\n",
        "for element in my_list:\n",
        "    print(element)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LsZDONGDZLtm",
        "outputId": "2ad2a8f9-59b2-4504-b9a7-41305715b6cb"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q5: Write a Python program to find the product of all elements in a list using a for loop.\n",
        "product = 1\n",
        "my_list = [1, 2, 3, 4, 5]\n",
        "for element in my_list:\n",
        "    product *= element\n",
        "print(\"Product of elements in the list:\", product)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nhIO-FeHZNZJ",
        "outputId": "c57fb752-7c48-49ad-96a6-723f4def7abd"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Product of elements in the list: 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q6: Create a Python program that prints all even numbers from 1 to 20 using a for loop.\n",
        "for i in range(2, 21, 2):\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GhCkPf-lZTPS",
        "outputId": "4c386245-0fdb-4cfe-b4c7-141d530e9a2e"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q7: Write a Python program that calculates the factorial of a number using a for loop.\n",
        "n = 5\n",
        "factorial = 1\n",
        "for i in range(1, n + 1):\n",
        "    factorial *= i\n",
        "print(\"Factorial of\", n, \"is\", factorial)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ScJd3jZIZTu_",
        "outputId": "a4615ac9-9578-4578-b02c-d6190fa4ade9"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Factorial of 5 is 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q8: How can you iterate through the characters of a string using a for loop in Python?\n",
        "# You can iterate through the characters of a string using a for loop by treating the string as a sequence of characters.\n",
        "# For example:\n",
        "my_string = \"Hello\"\n",
        "for char in my_string:\n",
        "    print(char)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XXxXnHUHZXQh",
        "outputId": "69bcf137-3662-46c1-db81-7dd8443b75b6"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "H\n",
            "e\n",
            "l\n",
            "l\n",
            "o\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q9: Write a Python program to find the largest number in a list using a for loop.\n",
        "my_list = [3, 7, 1, 9, 4, 2]\n",
        "largest = my_list[0]\n",
        "for num in my_list:\n",
        "    if num > largest:\n",
        "        largest = num\n",
        "print(\"Largest number in the list:\", largest)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQDjDUAUZYxZ",
        "outputId": "d79a7192-493a-4715-e987-e5fe03a22306"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Largest number in the list: 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q10: Create a Python program that prints the Fibonacci sequence up to a specified limit using a for loop.\n",
        "limit = 10\n",
        "fibonacci = [0, 1]\n",
        "for i in range(2, limit):\n",
        "    next_num = fibonacci[-1] + fibonacci[-2]\n",
        "    if next_num <= limit:\n",
        "        fibonacci.append(next_num)\n",
        "    else:\n",
        "        break\n",
        "print(\"Fibonacci sequence up to\", limit, \":\", fibonacci)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bWvZ21aSZZ78",
        "outputId": "c5e6db12-d14b-4d6c-a850-02981c90bc97"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fibonacci sequence up to 10 : [0, 1, 1, 2, 3, 5, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q11: Write a Python program to count the number of vowels in a given string using a for loop.\n",
        "string = \"Hello, World!\"\n",
        "vowels = \"AEIOUaeiou\"\n",
        "count = 0\n",
        "for char in string:\n",
        "    if char in vowels:\n",
        "        count += 1\n",
        "print(\"Number of vowels in the string:\", count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A4PLsDxKZdKP",
        "outputId": "781ee919-c898-44f8-81e7-dfa41647bdb8"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of vowels in the string: 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q12: Create a Python program that generates a multiplication table for a given number using a for loop.\n",
        "num = 5\n",
        "for i in range(1, 11):\n",
        "    product = num * i\n",
        "    print(f\"{num} x {i} = {product}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q5dctaqvZh7V",
        "outputId": "6dc445b3-346a-47c2-f646-54f9d10c70d0"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 x 1 = 5\n",
            "5 x 2 = 10\n",
            "5 x 3 = 15\n",
            "5 x 4 = 20\n",
            "5 x 5 = 25\n",
            "5 x 6 = 30\n",
            "5 x 7 = 35\n",
            "5 x 8 = 40\n",
            "5 x 9 = 45\n",
            "5 x 10 = 50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q13: Write a Python program to reverse a list using a for loop.\n",
        "my_list = [1, 2, 3, 4, 5]\n",
        "reversed_list = []\n",
        "for i in range(len(my_list) - 1, -1, -1):\n",
        "    reversed_list.append(my_list[i])\n",
        "print(\"Reversed list:\", reversed_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yc2P8eOMZjuq",
        "outputId": "a9cebe2a-fad7-46fe-f8b1-a436731108e6"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reversed list: [5, 4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q14: Write a Python program to find the common elements between two lists using a for loop.\n",
        "list1 = [1, 2, 3, 4, 5]\n",
        "list2 = [3, 4, 5, 6, 7]\n",
        "common_elements = []\n",
        "for element in list1:\n",
        "    if element in list2:\n",
        "        common_elements.append(element)\n",
        "print(\"Common elements between the two lists:\", common_elements)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mdQsGaucZlbB",
        "outputId": "dddb7715-fd7c-4a4e-a0bb-9384e3f63750"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Common elements between the two lists: [3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q15: Explain how to use a for loop to iterate through the keys and values of a dictionary in Python.\n",
        "# You can use the .items() method of a dictionary to iterate through both keys and values.\n",
        "# For example:\n",
        "my_dict = {'a': 1, 'b': 2, 'c': 3}\n",
        "for key, value in my_dict.items():\n",
        "    print(f\"Key: {key}, Value: {value}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cH85eAGjZm1U",
        "outputId": "b53cf63f-7cac-4c67-b228-5199e8447152"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Key: a, Value: 1\n",
            "Key: b, Value: 2\n",
            "Key: c, Value: 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q16: Write a Python program to find the GCD (Greatest Common Divisor) of two numbers using a for loop.\n",
        "def calculate_gcd(a, b):\n",
        "    while b:\n",
        "        a, b = b, a % b\n",
        "    return a\n",
        "\n",
        "num1 = 48\n",
        "num2 = 18\n",
        "gcd = calculate_gcd(num1, num2)\n",
        "print(\"GCD of\", num1, \"and\", num2, \"is\", gcd)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IZHnwTzpZpRD",
        "outputId": "39c9e6fc-91c4-4359-a6f8-8db18eb4b3c0"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GCD of 48 and 18 is 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q17: Create a Python program that checks if a string is a palindrome using a for loop.\n",
        "string = \"racecar\"\n",
        "is_palindrome = True\n",
        "for i in range(len(string) // 2):\n",
        "    if string[i] != string[len(string) - 1 - i]:\n",
        "        is_palindrome = False\n",
        "        break\n",
        "if is_palindrome:\n",
        "    print(\"It's a palindrome!\")\n",
        "else:\n",
        "    print(\"It's not a palindrome.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W7Mck1-zZr50",
        "outputId": "ad6f7bcb-2455-490c-ef2e-0dc590cd80aa"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It's a palindrome!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q18: Write a Python program to remove duplicates from a list using a for loop.\n",
        "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
        "unique_list = []\n",
        "for element in my_list:\n",
        "    if element not in unique_list:\n",
        "        unique_list.append(element)\n",
        "print(\"List with duplicates removed:\", unique_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vOazhdbLZtoX",
        "outputId": "532162a4-01c5-4d6d-acec-9751d7f0684f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "List with duplicates removed: [1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q19: Create a Python program that counts the number of words in a sentence using a for loop.\n",
        "sentence = \"This is a sample sentence.\"\n",
        "words = sentence.split()\n",
        "word_count = 0\n",
        "for word in words:\n",
        "    word_count += 1\n",
        "print(\"Number of words in the sentence:\", word_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hfkc7mnPZwN3",
        "outputId": "2f042d30-eda3-45f0-83b4-2c3eeb54a695"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of words in the sentence: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q20: Write a Python program to find the sum of all odd numbers from 1 to 50 using a for loop.\n",
        "sum_of_odds = 0\n",
        "for i in range(1, 51, 2):\n",
        "    sum_of_odds += i\n",
        "print(\"Sum of odd numbers from 1 to 50:\", sum_of_odds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oAQUrrSeZ1un",
        "outputId": "61f63323-1977-46d1-fb7a-729c6387d942"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of odd numbers from 1 to 50: 625\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q21: Write a Python program that checks if a given year is a leap year using a for loop.\n",
        "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",
        "year = 2024\n",
        "if is_leap_year(year):\n",
        "    print(year, \"is a leap year.\")\n",
        "else:\n",
        "    print(year, \"is not a leap year.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vrjSH6-0Z5Hw",
        "outputId": "0a2c4b22-4bf9-4136-ceed-9a8b7466e461"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2024 is a leap year.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q22: Create a Python program that calculates the square root of a number using a for loop.\n",
        "number = 25\n",
        "guess = number / 2\n",
        "for _ in range(10):\n",
        "    guess = 0.5 * (guess + number / guess)\n",
        "print(\"Square root of\", number, \"is approximately\", guess)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-hw7X77PZ7CB",
        "outputId": "2e4c10f7-2c55-4ea6-f5b9-c09593c4b2cd"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Square root of 25 is approximately 5.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q23: Write a Python program to find the LCM (Least Common Multiple) of two numbers using a for loop.\n",
        "def calculate_lcm(a, b):\n",
        "    lcm = a if a > b else b\n",
        "    while True:\n",
        "        if lcm % a == 0 and lcm % b == 0:\n",
        "            return lcm\n",
        "        lcm += 1\n",
        "\n",
        "num1 = 12\n",
        "num2 = 18\n",
        "lcm = calculate_lcm(num1, num2)\n",
        "print(\"LCM of\", num1, \"and\", num2, \"is\", lcm)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mztttDdHZ9CU",
        "outputId": "f8e4dbb9-0eca-444d-9c1f-22177adc1ad6"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LCM of 12 and 18 is 36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If else :\n"
      ],
      "metadata": {
        "id": "W0FuYi_7aNnA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Q1: Write a Python program to check if a number is positive, negative, or zero using an if-else statement.\n",
        "number = float(input(\"Enter a number: \"))\n",
        "if number > 0:\n",
        "    print(\"Positive number\")\n",
        "elif number < 0:\n",
        "    print(\"Negative number\")\n",
        "else:\n",
        "    print(\"Zero\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hFBQp5G5aPjk",
        "outputId": "d80eb410-4113-4b20-dce2-0590c90292fe"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 22\n",
            "Positive number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q2: Create a Python program that checks if a given number is even or odd using an if-else statement.\n",
        "number = int(input(\"Enter a number: \"))\n",
        "if number % 2 == 0:\n",
        "    print(\"Even number\")\n",
        "else:\n",
        "    print(\"Odd number\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y_jcQbPPaXqS",
        "outputId": "44a31c48-47a6-439e-d085-f421f918801e"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 23\n",
            "Odd number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q3: How can you use nested if-else statements in Python, and provide an example?\n",
        "# Nested if-else statements are used to have if-else statements inside other if-else statements.\n",
        "# Example:\n",
        "x = 10\n",
        "if x > 5:\n",
        "    if x < 15:\n",
        "        print(\"x is between 5 and 15\")\n",
        "    else:\n",
        "        print(\"x is greater than or equal to 15\")\n",
        "else:\n",
        "    print(\"x is less than or equal to 5\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cp74Nx6Zamed",
        "outputId": "6a533cfd-3f24-4f14-c9c1-830d6181a3c9"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x is between 5 and 15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q4: Write a Python program to determine the largest of three numbers using if-else.\n",
        "a = 5\n",
        "b = 10\n",
        "c = 7\n",
        "if a >= b and a >= c:\n",
        "    print(\"The largest number is\", a)\n",
        "elif b >= a and b >= c:\n",
        "    print(\"The largest number is\", b)\n",
        "else:\n",
        "    print(\"The largest number is\", c)\n",
        ""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eE9llZtRaoPZ",
        "outputId": "f4bb5e9c-0d11-4ed3-c929-4a9824ffad88"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The largest number is 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q5: Write a Python program that calculates the absolute value of a number using if-else.\n",
        "number = float(input(\"Enter a number: \"))\n",
        "if number < 0:\n",
        "    abs_value = -number\n",
        "else:\n",
        "    abs_value = number\n",
        "print(\"Absolute value:\", abs_value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VXoWeKeFap5q",
        "outputId": "d279a14e-30a7-403b-db88-bc6ee626cd4c"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 20\n",
            "Absolute value: 20.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q6: Create a Python program that checks if a given character is a vowel or consonant using if-else.\n",
        "char = input(\"Enter a character: \")\n",
        "if char.lower() in 'aeiou':\n",
        "    print(\"Vowel\")\n",
        "else:\n",
        "    print(\"Consonant\")\n",
        ""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aO2rgdlIatNu",
        "outputId": "b08bc83f-29ba-4653-8715-46db1dbc2314"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a character: e\n",
            "Vowel\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q7: Write a Python program to determine if a user is eligible to vote based on their age using if-else.\n",
        "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.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aNwRQ6ZVaw7e",
        "outputId": "cfe32808-4641-4b2a-cfb1-7e8f34cf9975"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your age: 20\n",
            "You are eligible to vote.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q8: Create a Python program that calculates the discount amount based on the purchase amount using if-else.\n",
        "purchase_amount = float(input(\"Enter purchase amount: \"))\n",
        "if purchase_amount >= 1000:\n",
        "    discount = 0.1 * purchase_amount\n",
        "else:\n",
        "    discount = 0\n",
        "print(\"Discount amount:\", discount)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iENsY8qCazbW",
        "outputId": "c584b10c-f669-479c-c94e-2b24b0403e96"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter purchase amount: 1000\n",
            "Discount amount: 100.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q9: Write a Python program to check if a number is within a specified range using if-else.\n",
        "number = int(input(\"Enter a number: \"))\n",
        "if 10 <= number <= 50:\n",
        "    print(\"Number is within the range.\")\n",
        "else:\n",
        "    print(\"Number is not within the range.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pxHKET6Ca4Jx",
        "outputId": "7043673c-70e0-4d5c-d0ff-3e57a135d296"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 12\n",
            "Number is within the range.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q10: Create a Python program that determines the grade of a student based on their score using if-else.\n",
        "score = int(input(\"Enter your score: \"))\n",
        "if score >= 90:\n",
        "    grade = \"A\"\n",
        "elif score >= 80:\n",
        "    grade = \"B\"\n",
        "elif score >= 70:\n",
        "    grade = \"C\"\n",
        "elif score >= 60:\n",
        "    grade = \"D\"\n",
        "else:\n",
        "    grade = \"F\"\n",
        "print(\"Your grade is:\", grade)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F-gemgoua5qE",
        "outputId": "99d23073-cb0c-442a-cf78-e6fbf2800870"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your score: 89\n",
            "Your grade is: B\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q11: Write a Python program to check if a string is empty or not using if-else.\n",
        "string = input(\"Enter a string: \")\n",
        "if not string:\n",
        "    print(\"String is empty.\")\n",
        "else:\n",
        "    print(\"String is not empty.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d0ipX6Zoa8SO",
        "outputId": "0e2e3502-4ff6-44e2-9f3e-55be94ef479b"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string: star\n",
            "String is not empty.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q12: Create a Python program that identifies the type of a triangle (e.g., equilateral, isosceles, or scalene) based on input values using if-else.\n",
        "side1 = float(input(\"Enter the length of side 1: \"))\n",
        "side2 = float(input(\"Enter the length of side 2: \"))\n",
        "side3 = float(input(\"Enter the length of side 3: \"))\n",
        "if side1 == side2 == side3:\n",
        "    triangle_type = \"Equilateral\"\n",
        "elif side1 == side2 or side2 == side3 or side1 == side3:\n",
        "    triangle_type = \"Isosceles\"\n",
        "else:\n",
        "    triangle_type = \"Scalene\"\n",
        "print(\"The triangle is:\", triangle_type)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y6g02s4wbBaO",
        "outputId": "d3d5e471-8604-4560-8277-20f3f40b1e5f"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the length of side 1: 12\n",
            "Enter the length of side 2: 12\n",
            "Enter the length of side 3: 12\n",
            "The triangle is: Equilateral\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q13: Write a Python program to determine the day of the week based on a user-provided number using if-else.\n",
        "day_number = int(input(\"Enter a day number (1-7): \"))\n",
        "if day_number == 1:\n",
        "    day_name = \"Monday\"\n",
        "elif day_number == 2:\n",
        "    day_name = \"Tuesday\"\n",
        "elif day_number == 3:\n",
        "    day_name = \"Wednesday\"\n",
        "elif day_number == 4:\n",
        "    day_name = \"Thursday\"\n",
        "elif day_number == 5:\n",
        "    day_name = \"Friday\"\n",
        "elif day_number == 6:\n",
        "    day_name = \"Saturday\"\n",
        "elif day_number == 7:\n",
        "    day_name = \"Sunday\"\n",
        "else:\n",
        "    day_name = \"Invalid\"\n",
        "print(\"Day of the week:\", day_name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VCtjTiR0bHMy",
        "outputId": "2f67b65d-091b-4c5c-800b-f7f400a30baa"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a day number (1-7): 5\n",
            "Day of the week: Friday\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q14: Create a Python program that checks if a given year is a leap year using both if-else and a function.\n",
        "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",
        "year = int(input(\"Enter a year: \"))\n",
        "if is_leap_year(year):\n",
        "    print(\"Leap year\")\n",
        "else:\n",
        "    print(\"Not a leap year\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AyppKuJ8bnLt",
        "outputId": "bec3025e-92ee-4927-d1ef-c9560cd73342"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a year: 2023\n",
            "Not a leap year\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q15: How do you use the \"assert\" statement in Python to add debugging checks within if-else blocks?\n",
        "# The \"assert\" statement is used for debugging and to make sure that a condition is True. If the condition is False, an AssertionError is raised.\n",
        "x = 10\n",
        "assert x > 5, \"x is not greater than 5\"  # This will not raise an error because the condition is True."
      ],
      "metadata": {
        "id": "EjBKfXEkbmEx"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Q16: Create a Python program that determines the eligibility of a person for a senior citizen discount based on age using if-else.\n",
        "age = int(input(\"Enter your age: \"))\n",
        "if age >= 60:\n",
        "    print(\"You are eligible for a senior citizen discount.\")\n",
        "else:\n",
        "    print(\"You are not eligible for a senior citizen discount.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9eQWkfDJbwlR",
        "outputId": "fd6a3f28-3541-4f0e-8cab-872b70705b1b"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your age: 60\n",
            "You are eligible for a senior citizen discount.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q17: Write a Python program to categorize a given character as uppercase, lowercase, or neither using if-else.\n",
        "char = input(\"Enter a character: \")\n",
        "if char.islower():\n",
        "    print(\"Lowercase character\")\n",
        "elif char.isupper():\n",
        "    print(\"Uppercase character\")\n",
        "else:\n",
        "    print(\"Neither uppercase nor lowercase character\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2DAn1FnFb0mU",
        "outputId": "8fce9519-e231-4af1-ff1e-439a8c7cbc89"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a character: star\n",
            "Lowercase character\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q18: Write a Python program to determine the roots of a quadratic equation using if-else.\n",
        "import math\n",
        "\n",
        "a = float(input(\"Enter coefficient a: \"))\n",
        "b = float(input(\"Enter coefficient b: \"))\n",
        "c = float(input(\"Enter coefficient c: \"))\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",
        "    print(\"Two distinct real roots: root1 =\", root1, \"and root2 =\", root2)\n",
        "elif discriminant == 0:\n",
        "    root1 = -b / (2*a)\n",
        "    print(\"One real root: root1 =\", root1)\n",
        "else:\n",
        "    real_part = -b / (2*a)\n",
        "    imaginary_part = math.sqrt(-discriminant) / (2*a)\n",
        "    print(\"Complex roots: root1 =\", real_part, \"+\", imaginary_part, \"i and root2 =\", real_part, \"-\", imaginary_part, \"i\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ARBgE-pb_pT",
        "outputId": "ceebe3b0-5d99-4a5d-a7db-ca8d708ea4bb"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter coefficient a: 2\n",
            "Enter coefficient b: 3\n",
            "Enter coefficient c: 4\n",
            "Complex roots: root1 = -0.75 + 1.1989578808281798 i and root2 = -0.75 - 1.1989578808281798 i\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q19: Create a Python program that checks if a given year is a century year or not using if-else.\n",
        "year = int(input(\"Enter a year: \"))\n",
        "if year % 100 == 0:\n",
        "    print(\"Century year\")\n",
        "else:\n",
        "    print(\"Not a century year\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xsFW-0Iub_xo",
        "outputId": "d73b7104-e339-4dda-b1a0-49b8ae45888e"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a year: 2000\n",
            "Century year\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q20: Write a Python program to determine if a given number is a perfect square using if-else.\n",
        "import math\n",
        "\n",
        "number = int(input(\"Enter a number: \"))\n",
        "sqrt = int(math.sqrt(number))\n",
        "if sqrt*sqrt == number:\n",
        "    print(\"Perfect square\")\n",
        "else:\n",
        "    print(\"Not a perfect square\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G87m7McfcxZk",
        "outputId": "cdff74d4-fc9d-4eef-fc5c-593dc94fedbe"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 4\n",
            "Perfect square\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q21: Explain the purpose of the \"continue\" and \"break\" statements within if-else loops.\n",
        "# - The \"continue\" statement is used to skip the rest of the current iteration and move to the next iteration of the loop.\n",
        "# - The \"break\" statement is used to exit the loop prematurely, stopping further iterations."
      ],
      "metadata": {
        "id": "rHmQ_fhQc1Xd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Q22: Create a Python program that calculates the BMI (Body Mass Index) of a person based on their weight and height using if-else.\n",
        "weight = float(input(\"Enter weight in kilograms: \"))\n",
        "height = float(input(\"Enter height in meters: \"))\n",
        "bmi = weight / (height**2)\n",
        "print(\"BMI:\", bmi)\n",
        "\n",
        "if bmi < 18.5:\n",
        "    print(\"Underweight\")\n",
        "elif 18.5 <= bmi < 25:\n",
        "    print(\"Normal weight\")\n",
        "elif 25 <= bmi < 30:\n",
        "    print(\"Overweight\")\n",
        "else:\n",
        "    print(\"Obese\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IRRINprqc15q",
        "outputId": "c9f6b68d-8239-4032-c2ed-8de3e3721929"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter weight in kilograms: 100\n",
            "Enter height in meters: 100\n",
            "BMI: 0.01\n",
            "Underweight\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q23: How can you use the \"filter()\" function with if-else statements to filter elements from a list?\n",
        "# You can use the \"filter()\" function along with a lambda function and if-else statements to filter elements from a list based on a condition.\n",
        "# Example:\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "filtered_numbers = list(filter(lambda x: x % 2 == 0, numbers))  # Filters even numbers\n",
        "print(filtered_numbers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Abr0t44Sc-iY",
        "outputId": "c091abf7-a7bc-4bcd-df4b-e6a4555cef08"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Q24: Write a Python program to determine if a given number is prime or not using if-else.\n",
        "number = int(input(\"Enter a number: \"))\n",
        "if number > 1:\n",
        "    for i in range(2, int(math.sqrt(number)) + 1):\n",
        "        if number % i == 0:\n",
        "            print(\"Not a prime number\")\n",
        "            break\n",
        "    else:\n",
        "        print(\"Prime number\")\n",
        "else:\n",
        "    print(\"Not a prime number\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FPOdIQ3AdC71",
        "outputId": "4474de44-c74d-4f32-e4e7-6c334d692f98"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 13\n",
            "Prime number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "MAP-"
      ],
      "metadata": {
        "id": "9oGy-PmJdNxW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q1: Explain the purpose of the map() function in Python and provide an example of how it can be used to apply a function to each element of an iterable.\n",
        "\n",
        "The map() function in Python is used to apply a specified function to each item in an iterable (e.g., a list, tuple, or string) and return an iterable map object. It allows you to transform every element of the iterable without the need for explicit loops.\n",
        "\n",
        "Example:"
      ],
      "metadata": {
        "id": "11A-aDL6dj6Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to square a number\n",
        "def square(x):\n",
        "    return x * x\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "# Use the map() function to square each element of the list\n",
        "squared_numbers = map(square, numbers)\n",
        "\n",
        "# Convert the map object to a list\n",
        "squared_numbers_list = list(squared_numbers)\n",
        "\n",
        "print(squared_numbers_list)  # Output: [1, 4, 9, 16, 25]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_y-mmDKdkrw",
        "outputId": "13a42df7-f678-4b36-ddc7-28cc80787253"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q2: Write a Python program that uses the map() function to square each element of a list of numbers."
      ],
      "metadata": {
        "id": "O3ErUPT7dsoO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to square a number\n",
        "def square(x):\n",
        "    return x * x\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "# Use the map() function to square each element of the list and convert the result to a list\n",
        "squared_numbers = list(map(square, numbers))\n",
        "\n",
        "print(squared_numbers)  # Output: [1, 4, 9, 16, 25]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QzKsZkSddutr",
        "outputId": "d71698cd-ee0c-47cc-dcef-9a49abfbb83a"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q3: How does the map() function differ from a list comprehension in Python, and when would you choose one over the other?\n",
        "\n",
        "The map() function and list comprehension can both be used to apply a function to each element of an iterable.\n",
        "The primary difference is that map() returns a map object that needs to be converted to a list or another iterable, while list comprehension directly generates a new list.\n",
        "List comprehension can be more concise and readable for simple operations, while map() may be preferred for more complex transformations or when working with functions that already exist."
      ],
      "metadata": {
        "id": "-O7MarHCdygy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q4: Create a Python program that uses the map() function to convert a list of names to uppercase.\n",
        "\n"
      ],
      "metadata": {
        "id": "RYd8SJXzd1pZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of names\n",
        "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\"]\n",
        "\n",
        "# Use the map() function to convert names to uppercase\n",
        "uppercase_names = list(map(str.upper, names))\n",
        "\n",
        "print(uppercase_names)  # Output: ['ALICE', 'BOB', 'CHARLIE', 'DAVID']\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wt8JuPIUdzwB",
        "outputId": "e1708471-966c-4150-b0ac-fe62428b6771"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['ALICE', 'BOB', 'CHARLIE', 'DAVID']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q5: Write a Python program that uses the map() function to calculate the length of each word in a list of strings."
      ],
      "metadata": {
        "id": "8Pam8h83d5dv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of strings\n",
        "words = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
        "\n",
        "# Use the map() function to calculate the length of each word\n",
        "word_lengths = list(map(len, words))\n",
        "\n",
        "print(word_lengths)  # Output: [5, 6, 6, 4]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bod0RwVed6Dk",
        "outputId": "82915041-573d-42d2-f214-25c7e8dd571c"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 6, 6, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q6: How can you use the map() function to apply a custom function to elements of multiple lists simultaneously in Python?\n",
        "\n",
        "You can use the map() function with multiple iterable arguments to apply a custom function to corresponding elements of those iterables. The function should take as many arguments as there are input iterables.\n",
        "\n",
        "Example:"
      ],
      "metadata": {
        "id": "J-paws_Dd-PK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a custom function that takes two arguments and returns their sum\n",
        "def add(x, y):\n",
        "    return x + y\n",
        "\n",
        "# Create two lists\n",
        "list1 = [1, 2, 3]\n",
        "list2 = [10, 20, 30]\n",
        "\n",
        "# Use the map() function to apply the custom function to corresponding elements\n",
        "result = list(map(add, list1, list2))\n",
        "\n",
        "print(result)  # Output: [11, 22, 33]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5t-XFGkWeAqu",
        "outputId": "22a5c458-7a95-48b5-e1cf-e6bed12490f4"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 22, 33]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q7: Create a Python program that uses map() to convert a list of temperatures from Celsius to Fahrenheit."
      ],
      "metadata": {
        "id": "ZKXuytYneB6o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to convert Celsius to Fahrenheit\n",
        "def celsius_to_fahrenheit(celsius):\n",
        "    return (celsius * 9/5) + 32\n",
        "\n",
        "# Create a list of temperatures in Celsius\n",
        "celsius_temperatures = [0, 10, 20, 30, 40]\n",
        "\n",
        "# Use the map() function to convert temperatures to Fahrenheit\n",
        "fahrenheit_temperatures = list(map(celsius_to_fahrenheit, celsius_temperatures))\n",
        "\n",
        "print(fahrenheit_temperatures)  # Output: [32.0, 50.0, 68.0, 86.0, 104.0]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VOJVIEN9eD7J",
        "outputId": "8abd8944-f07e-4046-8d4b-d43bcc084e9f"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[32.0, 50.0, 68.0, 86.0, 104.0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q8: Write a Python program that uses the map() function to round each element of a list of floating-point numbers to the nearest integer"
      ],
      "metadata": {
        "id": "knaYEn9ZeFgn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of floating-point numbers\n",
        "float_numbers = [3.7, 2.2, 4.8, 1.5, 9.1]\n",
        "\n",
        "# Use the map() function to round each number to the nearest integer\n",
        "rounded_numbers = list(map(round, float_numbers))\n",
        "\n",
        "print(rounded_numbers)  # Output: [4, 2, 5, 2, 9]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "848IwfwMeHP0",
        "outputId": "af1882f8-4e30-4128-bced-2e9a344111db"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 2, 5, 2, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "REDUCE-"
      ],
      "metadata": {
        "id": "C5ELWyu0eQJw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q1: What is the reduce() function in Python, and what module should you import to use it? Provide an example of its basic usage.\n",
        "\n",
        "The reduce() function in Python is used for cumulative computation. It is available in the functools module, so you need to import the functools module to use it.\n",
        "\n",
        "Example of basic usage:"
      ],
      "metadata": {
        "id": "VJocmSCGeT-v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function that adds two numbers\n",
        "def add(x, y):\n",
        "    return x + y\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "# Use the reduce() function to find the sum of all numbers in the list\n",
        "sum_result = functools.reduce(add, numbers)\n",
        "\n",
        "print(sum_result)  # Output: 15 (1 + 2 + 3 + 4 + 5)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1bKooNwZeRhD",
        "outputId": "823e5dcb-e5f5-4928-94b2-7d212a411415"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q2: Write a Python program that uses the reduce() function to find the product of all elements in a list."
      ],
      "metadata": {
        "id": "w-Uuh_dJeVzs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function that multiplies two numbers\n",
        "def multiply(x, y):\n",
        "    return x * y\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "# Use the reduce() function to find the product of all numbers in the list\n",
        "product_result = functools.reduce(multiply, numbers)\n",
        "\n",
        "print(product_result)  # Output: 120 (1 * 2 * 3 * 4 * 5)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PxxUQnkPeYBK",
        "outputId": "91234816-875f-498d-c7e1-1d7437cec89d"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q3: Create a Python program that uses reduce() to find the maximum element in a list of numbers."
      ],
      "metadata": {
        "id": "qLtpL9_weaZa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function to find the maximum of two numbers\n",
        "def find_max(x, y):\n",
        "    return max(x, y)\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [12, 45, 23, 67, 8, 99, 54]\n",
        "\n",
        "# Use the reduce() function to find the maximum element in the list\n",
        "max_result = functools.reduce(find_max, numbers)\n",
        "\n",
        "print(max_result)  # Output: 99 (maximum element in the list)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AAvTxuYXebG-",
        "outputId": "ff3d77fd-a21f-4673-fe08-1ed649fca65b"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "99\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q4: How can you use the reduce() function to concatenate a list of strings into a single string?\n",
        "\n",
        "To concatenate a list of strings into a single string using the reduce() function, you can define a function that concatenates two strings and apply it to the list of strings.\n",
        "\n",
        "Example:\n"
      ],
      "metadata": {
        "id": "Wuux0315ec18"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function to concatenate two strings\n",
        "def concatenate_strings(x, y):\n",
        "    return x + y\n",
        "\n",
        "# Create a list of strings\n",
        "strings = [\"Hello, \", \"World\", \"!\"]\n",
        "\n",
        "# Use the reduce() function to concatenate the strings in the list\n",
        "concatenated_string = functools.reduce(concatenate_strings, strings)\n",
        "\n",
        "print(concatenated_string)  # Output: \"Hello, World!\"\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AnlrhYMyefQ5",
        "outputId": "9de2e94c-5022-439e-edbc-52e2c1c76335"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, World!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q5: Write a Python program that calculates the factorial of a number using the reduce() function."
      ],
      "metadata": {
        "id": "trqNGOu1eiEU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function to calculate the factorial of a number\n",
        "def calculate_factorial(x, y):\n",
        "    return x * y\n",
        "\n",
        "# Input: Number for which factorial is to be calculated\n",
        "number = 5\n",
        "\n",
        "# Create a list of numbers from 1 to the input number\n",
        "numbers = list(range(1, number + 1))\n",
        "\n",
        "# Use the reduce() function to calculate the factorial\n",
        "factorial_result = functools.reduce(calculate_factorial, numbers)\n",
        "\n",
        "print(factorial_result)  # Output: 120 (5!)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "boPlOuDUei9c",
        "outputId": "8b7b0f0a-8aac-4ee8-8598-d45f0ace33f3"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q6: Create a Python program that uses reduce() to find the GCD (Greatest Common Divisor) of a list of numbers."
      ],
      "metadata": {
        "id": "H4lp8ALKenih"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "import math\n",
        "\n",
        "# Define a function to find the GCD of two numbers\n",
        "def find_gcd(x, y):\n",
        "    return math.gcd(x, y)\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [24, 36, 48, 60]\n",
        "\n",
        "# Use the reduce() function to find the GCD of the numbers in the list\n",
        "gcd_result = functools.reduce(find_gcd, numbers)\n",
        "\n",
        "print(gcd_result)  # Output: 12 (GCD of the numbers)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QIWZx-B6emLa",
        "outputId": "d07118c2-b625-48c7-942a-f8559a3e7a2c"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q7: Write a Python program that uses the reduce() function to find the sum of the digits of a given number."
      ],
      "metadata": {
        "id": "OttQqNCner7d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "# Define a function to add the digits of a number\n",
        "def add_digits(x, y):\n",
        "    return int(x) + int(y)\n",
        "\n",
        "# Input: Number for which sum of digits is to be calculated\n",
        "number = 12345\n",
        "\n",
        "# Convert the number to a string to access its digits\n",
        "number_str = str(number)\n",
        "\n",
        "# Use the reduce() function to find the sum of the digits\n",
        "sum_of_digits = functools.reduce(add_digits, number_str)\n",
        "\n",
        "print(sum_of_digits)  # Output: 15 (1 + 2 + 3 + 4 + 5)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H4AMTRdrerqo",
        "outputId": "8b0a49cc-f0c5-4b1c-d395-33c44fdddd2c"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "FILTER-"
      ],
      "metadata": {
        "id": "tuBBcq2ke0tt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Q1: Explain the purpose of the filter() function in Python and provide an example of how it can be used to filter elements from an iterable.\n",
        "\n",
        "#The filter() function in Python is used to filter elements from an iterable (such as a list) based on a specified condition. It takes two arguments: a function that defines the condition, and an iterable to filter. The function is applied to each element of the iterable, and only the elements that satisfy the condition are included in the output.\n",
        "\n",
        "#Example of basic usage:\n",
        "\n",
        "# Define a function that checks if a number is even\n",
        "def is_even(number):\n",
        "    return number % 2 == 0\n",
        "\n",
        "# Create a list of numbers\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "# Use the filter() function to select even numbers from the list\n",
        "even_numbers = list(filter(is_even, numbers))\n",
        "\n",
        "print(even_numbers)  # Output: [2, 4, 6, 8, 10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FaIFMaQ6e1td",
        "outputId": "bfcc6e32-595f-4f42-bd32-f109bd75532e"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q2: Write a Python program that uses the filter() function to select even numbers from a list of integers.\n",
        "\n",
        "\n",
        "# Define a function that checks if a number is even\n",
        "def is_even(number):\n",
        "    return number % 2 == 0\n",
        "\n",
        "# Create a list of integers\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "# Use the filter() function to select even numbers from the list\n",
        "even_numbers = list(filter(is_even, numbers))\n",
        "\n",
        "print(even_numbers)  # Output: [2, 4, 6, 8, 10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qkGyLEovfC5I",
        "outputId": "1c7049de-9b88-459f-98e3-ac961933592c"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q3: Create a Python program that uses the filter() function to select names that start with a specific letter from a list of strings.\n",
        "\n",
        "# Define a function that checks if a name starts with a specific letter\n",
        "def starts_with_letter(letter, name):\n",
        "    return name.startswith(letter)\n",
        "\n",
        "# Create a list of names\n",
        "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\"]\n",
        "\n",
        "# Choose a letter to filter by\n",
        "letter_to_filter = \"C\"\n",
        "\n",
        "# Use the filter() function to select names starting with the specified letter\n",
        "filtered_names = list(filter(lambda name: starts_with_letter(letter_to_filter, name), names))\n",
        "\n",
        "print(filtered_names)  # Output: [\"Charlie\"]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RIufesbnfK4l",
        "outputId": "0d507c22-b3b8-48e6-f90f-dbb4ddb208bb"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Charlie']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q4: Write a Python program that uses the filter() function to select prime numbers from a list of integers.\n",
        "\n",
        "# Define a function that checks if a number is prime\n",
        "def is_prime(number):\n",
        "    if number <= 1:\n",
        "        return False\n",
        "    for i in range(2, int(number ** 0.5) + 1):\n",
        "        if number % i == 0:\n",
        "            return False\n",
        "    return True\n",
        "\n",
        "# Create a list of integers\n",
        "numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\n",
        "\n",
        "# Use the filter() function to select prime numbers from the list\n",
        "prime_numbers = list(filter(is_prime, numbers))\n",
        "\n",
        "print(prime_numbers)  # Output: [2, 3, 5, 7, 11, 13]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MM6fzbGJfQKG",
        "outputId": "cd2af106-def7-4096-fb1b-7bde047e571a"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 5, 7, 11, 13]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q5: How can you use the filter() function to remove None values from a list in Python?\n",
        "\n",
        "#You can use the filter() function with a lambda function that filters out None values by checking if each element is not equal to None.\n",
        "\n",
        "#Example:\n",
        "\n",
        "# Create a list with some None values\n",
        "values = [1, 2, None, 4, None, 6, None]\n",
        "\n",
        "# Use the filter() function to remove None values from the list\n",
        "filtered_values = list(filter(lambda x: x is not None, values))\n",
        "\n",
        "print(filtered_values)  # Output: [1, 2, 4, 6"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-h4HqoU5fTdz",
        "outputId": "d21a90f6-40ef-4915-9d2e-700fe1a3a5d6"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 4, 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q6: Create a Python program that uses filter() to select words longer than a certain length from a list of strings.\n",
        "\n",
        "# Define a function that checks if a word is longer than a specified length\n",
        "def is_long_word(word, length):\n",
        "    return len(word) > length\n",
        "\n",
        "# Create a list of words\n",
        "words = [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\"]\n",
        "\n",
        "# Specify the minimum length for words to be selected\n",
        "min_length = 6\n",
        "\n",
        "# Use the filter() function to select words longer than the specified length\n",
        "long_words = list(filter(lambda word: is_long_word(word, min_length), words))\n",
        "\n",
        "print(long_words)  # Output: [\"cherry\", \"elderberry\"]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uZjix7UVfYrK",
        "outputId": "790612af-5108-4682-8afe-cbdf9b81997e"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['elderberry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Q7 Write a Python program that uses the `filter()` function to select elements greater than a specified threshold from a list of values\n",
        "\n",
        "# Define a function that checks if a value is greater than the threshold\n",
        "def is_greater_than_threshold(value, threshold):\n",
        "    return value > threshold\n",
        "\n",
        "# Create a list of values\n",
        "values = [15, 30, 10, 45, 25, 5, 50]\n",
        "\n",
        "# Specify the threshold value for filtering\n",
        "threshold = 20\n",
        "\n",
        "# Use the filter() function to select values greater than the threshold\n",
        "filtered_values = list(filter(lambda value: is_greater_than_threshold(value, threshold), values))\n",
        "\n",
        "print(filtered_values)  # Output: [30, 45, 25, 50]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ONNu--n1fk6R",
        "outputId": "4a4f0495-9e90-43b3-832f-bff77e01e3b4"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[30, 45, 25, 50]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "RECURSION-\n",
        "\n"
      ],
      "metadata": {
        "id": "5ucXfdAxfx20"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q1 Explain the concept of recursion in Python. How does it differ from iteration?\n",
        "Recursion in Python is a programming technique where a function calls itself to solve a problem. It's a way to break down a complex problem into smaller, more manageable subproblems. Recursion differs from iteration in that it uses function calls to repeat a process, whereas iteration uses loops to repeat a block of code. Recursion often results in more concise and elegant code for certain types of problems, but it can be less efficient in terms of memory usage compared to iteration."
      ],
      "metadata": {
        "id": "OPAuWuFdf15i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program to calculate the factorial of a number using recursion.\n",
        "\n"
      ],
      "metadata": {
        "id": "kkVT9KisgFKc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def factorial(n):\n",
        "    if n == 0:\n",
        "        return 1\n",
        "    else:\n",
        "        return n * factorial(n - 1)\n",
        "\n",
        "num = 5\n",
        "print(f\"Factorial of {num} is {factorial(num)}\")  # Output: Factorial of 5 is 120\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6dhNqUc6f2q2",
        "outputId": "fbe7c2d0-db3b-48da-8326-187bf266c302"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Factorial of 5 is 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def fibonacci(n):\n",
        "    if n <= 1:\n",
        "        return n\n",
        "    else:\n",
        "        return fibonacci(n - 1) + fibonacci(n - 2)\n",
        "\n",
        "num = 7\n",
        "print(f\"The {num}th Fibonacci number is {fibonacci(num)}\")  # Output: The 7th Fibonacci number is 13\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VaIC_nLugKED",
        "outputId": "023b5141-ef6f-478e-c9bc-460da33cb897"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The 7th Fibonacci number is 13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_list(lst):\n",
        "    if not lst:\n",
        "        return 0\n",
        "    else:\n",
        "        return lst[0] + sum_list(lst[1:])\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "print(f\"Sum of the list is {sum_list(numbers)}\")  # Output: Sum of the list is 15\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T17NiR3OgLbk",
        "outputId": "9b812fab-9751-4eca-cfb4-ffc3d3f20988"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of the list is 15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5 How can you prevent a recursive function from running indefinitely, causing a stack overflow error?\n",
        "\n",
        "To prevent a recursive function from running indefinitely, you should define a base case that provides a termination condition. Ensure that the recursive function approaches this base case with each recursive call. Without a base case or if the base case is never reached, it can lead to a stack overflow error."
      ],
      "metadata": {
        "id": "7HGlOUAwgNT6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gcd(a, b):\n",
        "    if b == 0:\n",
        "        return a\n",
        "    else:\n",
        "        return gcd(b, a % b)\n",
        "\n",
        "num1, num2 = 48, 18\n",
        "print(f\"GCD of {num1} and {num2} is {gcd(num1, num2)}\")  # Output: GCD of 48 and 18 is 6\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8ixWoAr2gY6y",
        "outputId": "9f96cb60-0ee6-46c8-e630-0f11c1a0ef39"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GCD of 48 and 18 is 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def reverse_string(s):\n",
        "    if not s:\n",
        "        return s\n",
        "    else:\n",
        "        return reverse_string(s[1:]) + s[0]\n",
        "\n",
        "text = \"hello\"\n",
        "print(f\"Reversed string: {reverse_string(text)}\")  # Output: Reversed string: olleh\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VsTMgw1gZfS",
        "outputId": "e1a40226-31c5-4da6-aab3-761ca5bf959e"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reversed string: olleh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def power(x, n):\n",
        "    if n == 0:\n",
        "        return 1\n",
        "    else:\n",
        "        return x * power(x, n - 1)\n",
        "\n",
        "base, exponent = 2, 3\n",
        "print(f\"{base}^{exponent} is {power(base, exponent)}\")  # Output: 2^3 is 8\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wBHg7McZgdc4",
        "outputId": "cfd8bccd-4432-47ad-80d8-fa50c98a206f"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2^3 is 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def permutations(s):\n",
        "    if len(s) == 1:\n",
        "        return [s]\n",
        "    else:\n",
        "        perms = []\n",
        "        for char in s:\n",
        "            remaining_chars = s.replace(char, \"\", 1)\n",
        "            sub_perms = permutations(remaining_chars)\n",
        "            for perm in sub_perms:\n",
        "                perms.append(char + perm)\n",
        "        return perms\n",
        "\n",
        "word = \"abc\"\n",
        "print(f\"Permutations of '{word}': {permutations(word)}\")\n",
        "# Output: Permutations of 'abc': ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oPVMtXmOgfna",
        "outputId": "bcea5295-38ac-4c50-c0aa-b3fe893d909b"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Permutations of 'abc': ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def is_palindrome(s):\n",
        "    s = s.lower()\n",
        "    s = ''.join(filter(str.isalnum, s))  # Remove non-alphanumeric characters\n",
        "    if len(s) <= 1:\n",
        "        return True\n",
        "    elif s[0] == s[-1]:\n",
        "        return is_palindrome(s[1:-1])\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "text = \"A man, a plan, a canal, Panama\"\n",
        "print(f\"Is '{text}' a palindrome? {is_palindrome(text)}\")  # Output: Is 'A man, a plan, a canal, Panama' a palindrome? True\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fk2orL4vghh7",
        "outputId": "370d9376-5c5c-46d6-a7e8-a747a0516653"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is 'A man, a plan, a canal, Panama' a palindrome? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def combinations(arr, k):\n",
        "    if k == 0:\n",
        "        return [[]]\n",
        "    if not arr:\n",
        "        return []\n",
        "    head, tail = arr[0], arr[1:]\n",
        "    without_head = combinations(tail, k)\n",
        "    with_head = combinations(tail, k - 1)\n",
        "    for combo in with_head:\n",
        "        combo.append(head)\n",
        "    return without_head + with_head\n",
        "\n",
        "elements = [1, 2, 3]\n",
        "k = 2\n",
        "print(f\"Combinations of {elements} (k={k}): {combinations(elements, k)}\")\n",
        "# Output: Combinations of [1, 2, 3] (k=2): [[2, 3], [1, 3], [1, 2]]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MWRTENBWgi4M",
        "outputId": "41c2e30a-e6e3-4fdc-b00d-deb40a3ed62e"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Combinations of [1, 2, 3] (k=2): [[3, 2], [3, 1], [2, 1]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Basics of Functions:\n"
      ],
      "metadata": {
        "id": "f_gK3dAxgpyH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "What is a function in Python, and why is it used?\n",
        "\n",
        "A function in Python is a reusable block of code that performs a specific task.\n",
        "Functions are used to modularize code, making it more organized, readable, and maintainable. They allow you to break down a program into smaller, manageable parts, which can be tested and reused as needed."
      ],
      "metadata": {
        "id": "vsfHhFTogsPn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "How do you define a function in Python? Provide an example.\n",
        "\n",
        "You can define a function in Python using the def keyword, followed by the function name, parentheses, and a colon. The function body is indented.\n",
        "Example:"
      ],
      "metadata": {
        "id": "-SRwfPzkgvCg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name):\n",
        "    \"\"\"This function greets the person passed in as a parameter.\"\"\"\n",
        "    print(f\"Hello, {name}!\")\n",
        "\n",
        "# Function call\n",
        "greet(\"Alice\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jw3kzVnwgqfF",
        "outputId": "861ae55c-4a55-4016-b732-d1cbe1ebfb46"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Alice!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Explain the difference between a function definition and a function call.\n",
        "\n",
        "Function Definition: Defining a function means specifying its name, parameters, and the code to be executed when the function is called. It's like creating a blueprint.\n",
        "Function Call: Calling a function means executing the code within the function's body with specific arguments. It's like using the blueprint to build something."
      ],
      "metadata": {
        "id": "tfHv82FNgylx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_numbers(a, b):\n",
        "    \"\"\"This function calculates the sum of two numbers.\"\"\"\n",
        "    return a + b\n",
        "\n",
        "result = add_numbers(5, 3)\n",
        "print(\"Sum:\", result)  # Output: Sum: 8\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDn9M-KRg77A",
        "outputId": "0331c20d-224f-479f-877d-27fa8de0264a"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum: 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What is a function signature, and what information does it typically include?\n",
        "\n",
        "A function signature typically includes the function name, parameters (if any), and the return type (if specified).\n",
        "For example, in the function def add_numbers(a, b):, the signature includes the name add_numbers, parameters a and b, and no explicit return type (it returns whatever the + operator returns, which is inferred)."
      ],
      "metadata": {
        "id": "nwx_Kj7thA24"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def multiply(a, b):\n",
        "    \"\"\"This function calculates the product of two numbers.\"\"\"\n",
        "    return a * b\n",
        "\n",
        "result = multiply(4, 7)\n",
        "print(\"Product:\", result)  # Output: Product: 28\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DGaoUSOThCRh",
        "outputId": "7e93b061-62d6-4c70-f57f-253abcd6ebbe"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Product: 28\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function Parameters and Arguments:\n"
      ],
      "metadata": {
        "id": "Zl0K6s8vhJCI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Explain the concepts of formal parameters and actual arguments in Python functions:\n",
        "\n",
        "Formal Parameters: These are placeholders in the function definition that represent the data or values a function expects when it's called. They act as variables inside the function.\n",
        "Actual Arguments: These are the values or expressions that are passed to a function when it's called. They correspond to the formal parameters and provide the data the function operates"
      ],
      "metadata": {
        "id": "dG4g29cGhLru"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program that defines a function with default argument values:\n",
        "\n",
        "In Python, you can define default values for function parameters. If an argument is not provided when calling the function, it uses the default value."
      ],
      "metadata": {
        "id": "dDK-RGoihO_o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name=\"Guest\"):\n",
        "    \"\"\"This function greets a person with a default message.\"\"\"\n",
        "    print(f\"Hello, {name}!\")\n",
        "\n",
        "greet()           # Output: Hello, Guest!\n",
        "greet(\"Alice\")    # Output: Hello, Alice!\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fy5kEgqnhPqZ",
        "outputId": "c3b9c056-87a5-4bf5-d018-4f7b83ae8ea1"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Guest!\n",
            "Hello, Alice!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "How do you use keyword arguments in Python function calls? Provide an example:\n",
        "\n",
        "Keyword arguments are passed to a function by specifying the parameter name and the value to be associated with it."
      ],
      "metadata": {
        "id": "vxGKu5EwhRQ-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add(a, b):\n",
        "    return a + b\n",
        "\n",
        "result = add(b=3, a=5)  # Using keyword arguments\n",
        "print(\"Sum:\", result)   # Output: Sum: 8\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I_zL2xmyhUfs",
        "outputId": "836d2c3f-d801-4cdb-906f-884302ae0ed8"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum: 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a Python function that accepts a variable number of arguments and calculates their sum:\n",
        "\n",
        "You can use *args to accept a variable number of positional arguments in a function."
      ],
      "metadata": {
        "id": "DgubMOAOhSeS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_sum(*args):\n",
        "    \"\"\"This function calculates the sum of all arguments.\"\"\"\n",
        "    return sum(args)\n",
        "\n",
        "result = calculate_sum(1, 2, 3, 4, 5)\n",
        "print(\"Sum:\", result)  # Output: Sum: 15\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gMxFtDDnhZT6",
        "outputId": "fa599fe3-461b-42bc-dd42-f9039349cfdb"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum: 15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What is the purpose of the *args and **kwargs syntax in function parameter lists?\n",
        "\n",
        "*args: It allows a function to accept a variable number of positional arguments. It collects extra positional arguments into a tuple.\n",
        "**kwargs: It allows a function to accept a variable number of keyword arguments (key-value pairs). It collects extra keyword arguments into a dictionary.\n",
        "These syntaxes are useful when you want to make functions more flexible and handle various argument scenarios.\n",
        "\n"
      ],
      "metadata": {
        "id": "_B0NK3wehbi5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Return Values and Scoping:\n"
      ],
      "metadata": {
        "id": "LWTB2wGWhc0E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Describe the role of the return statement in Python functions and provide examples:\n",
        "\n",
        "The return statement is used in Python functions to specify the value that the function should produce as its result. When a function encounters a return statement, it stops executing and returns the specified value to the caller.\n"
      ],
      "metadata": {
        "id": "3VGWMqrhhnHI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add(a, b):\n",
        "    result = a + b\n",
        "    return result\n",
        "\n",
        "sum_result = add(3, 4)\n",
        "print(\"Sum:\", sum_result)  # Output: Sum: 7\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lf3tq33lhclu",
        "outputId": "2cd8ebe7-070b-4b07-f315-a75940f63ce6"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Explain the concept of variable scope in Python, including local and global variables:\n",
        "\n",
        "Local Variables: Variables defined within a function are called local variables. They have a local scope, which means they are only accessible within that function.\n",
        "Global Variables: Variables defined outside of any function are called global variables. They have a global scope, which means they can be accessed from any part of the program, including within functions."
      ],
      "metadata": {
        "id": "RcY9Ro_Ehqg4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program that demonstrates the use of global variables within functions:\n",
        "\n",
        "Global variables can be accessed within functions, but if you want to modify their values within a function, you need to use the global keyword."
      ],
      "metadata": {
        "id": "lWJnKfGrhszo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "global_variable = 10\n",
        "\n",
        "def modify_global():\n",
        "    global global_variable\n",
        "    global_variable = 20\n",
        "\n",
        "modify_global()\n",
        "print(\"Global Variable:\", global_variable)  # Output: Global Variable: 20\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KJRmHwCdhvdI",
        "outputId": "1ed7725f-89fd-4512-fa64-04a65dfb77c3"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Global Variable: 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a Python function that calculates the factorial of a number and returns it:\n",
        "\n"
      ],
      "metadata": {
        "id": "9_FffHu6hxtx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def factorial(n):\n",
        "    if n == 0:\n",
        "        return 1\n",
        "    else:\n",
        "        return n * factorial(n - 1)\n",
        "\n",
        "result = factorial(5)\n",
        "print(\"Factorial:\", result)  # Output: Factorial: 120\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zo4qOmgDhyTO",
        "outputId": "9c649f4f-02e5-4e8b-cb8e-4510b27420eb"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Factorial: 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "How can you access variables defined outside a function from within the function?\n",
        "\n",
        "You can access global variables within a function without any special keyword. However, if you want to modify the value of a global variable from within a function, you need to use the global keyword to indicate that you are working with the global variable.\n"
      ],
      "metadata": {
        "id": "JPVn2B2yhzMk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "global_variable = 10\n",
        "\n",
        "def access_global():\n",
        "    print(\"Global Variable Value:\", global_variable)\n",
        "\n",
        "access_global()  # Output: Global Variable Value: 10\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ur_ggy3Xh3x_",
        "outputId": "b233ec24-4981-4bb2-ee93-9cc93f06d0ed"
      },
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Global Variable Value: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lambda Functions and Higher-Order Functions:\n"
      ],
      "metadata": {
        "id": "oeBOhji5h3bE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "What are lambda functions in Python, and when are they typically used?\n",
        "\n",
        "Lambda functions, also known as anonymous functions, are small, unnamed functions defined using the lambda keyword. They are typically used when you need a simple function for a short period of time and don't want to define a full function using the def keyword. Lambda functions are often used for tasks like sorting, filtering, or mapping data.\n",
        "\n"
      ],
      "metadata": {
        "id": "L4W2SESxh-mw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program that uses lambda functions to sort a list of tuples based on the second element:"
      ],
      "metadata": {
        "id": "pC3hTSJciBcB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = [(1, 5), (3, 2), (2, 8), (4, 1)]\n",
        "sorted_data = sorted(data, key=lambda x: x[1])\n",
        "print(sorted_data)\n",
        "# Output: [(4, 1), (3, 2), (1, 5), (2, 8)]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5oV19e29iDS5",
        "outputId": "f47b84e6-6bc6-4f7e-c7a1-cdbc0a8a941c"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(4, 1), (3, 2), (1, 5), (2, 8)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Explain the concept of higher-order functions in Python, and provide an example:\n",
        "\n",
        "Higher-order functions are functions that can accept other functions as arguments, return functions as results, or both. In Python, functions are first-class citizens, which means they can be treated like any other data type. Higher-order functions are used to create more flexible and reusable code by allowing you to pass behavior (functions) as data."
      ],
      "metadata": {
        "id": "X5rK31Z-iFZU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def apply_operation(numbers, operation):\n",
        "    result = []\n",
        "    for num in numbers:\n",
        "        result.append(operation(num))\n",
        "    return result\n",
        "\n",
        "def square(x):\n",
        "    return x ** 2\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "squared_numbers = apply_operation(numbers, square)\n",
        "print(squared_numbers)\n",
        "# Output: [1, 4, 9, 16, 25]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eW_1sEnjiF9o",
        "outputId": "4fdb060a-555d-4bfd-b021-a909612ae0f1"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a Python function that takes a list of numbers and a function as arguments, applying the function to each element in the list:"
      ],
      "metadata": {
        "id": "PO1-UGDKiIKE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def apply_function_to_list(numbers, func):\n",
        "    result = []\n",
        "    for num in numbers:\n",
        "        result.append(func(num))\n",
        "    return result\n",
        "\n",
        "def double(x):\n",
        "    return x * 2\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "doubled_numbers = apply_function_to_list(numbers, double)\n",
        "print(doubled_numbers)\n",
        "# Output: [2, 4, 6, 8, 10]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XR5a02_GiJhB",
        "outputId": "cae1093a-fea1-49a0-acb0-439eed7713cf"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Built-in Functions:\n"
      ],
      "metadata": {
        "id": "zBmEdO6niOrE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Describe the role of built-in functions like len(), max(), and min() in Python:\n",
        "\n",
        "Built-in functions like len(), max(), and min() are part of Python's standard library and serve specific purposes:\n",
        "len(): It returns the number of items in an iterable (e.g., a list, string, or tuple).\n",
        "max(): It returns the largest item in an iterable or the largest of two or more arguments.\n",
        "min(): It returns the smallest item in an iterable or the smallest of two or more arguments.\n",
        "These functions are commonly used for data analysis, finding extremum values, and determining the length of data structures."
      ],
      "metadata": {
        "id": "ZUkTupF4iRNb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program that uses the map() function to apply a function to each element of a list:\n",
        "\n"
      ],
      "metadata": {
        "id": "k6ovB6PtiXDt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def square(x):\n",
        "    return x ** 2\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "squared_numbers = list(map(square, numbers))\n",
        "print(squared_numbers)\n",
        "# Output: [1, 4, 9, 16, 25]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wOGdCiKbiPMg",
        "outputId": "09ba963e-3a57-4fdd-f0a9-35731f2eed60"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "How does the filter() function work in Python, and when would you use it?\n",
        "\n",
        "The filter() function is used to filter elements from an iterable (e.g., a list) based on a given function's criteria. It returns an iterable containing only the elements for which the function returns True. You would use filter() when you need to select specific elements from a collection based on some condition."
      ],
      "metadata": {
        "id": "68xJH5NoicUe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_even(x):\n",
        "    return x % 2 == 0\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "even_numbers = list(filter(is_even, numbers))\n",
        "print(even_numbers)\n",
        "# Output: [2, 4, 6, 8]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hj7amNuDieWa",
        "outputId": "594a3e69-7b0f-471e-a6d0-adc9596120f4"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a Python program that uses the reduce() function to find the product of all elements in a list:"
      ],
      "metadata": {
        "id": "YsYOkhFfigJG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import reduce\n",
        "\n",
        "def multiply(x, y):\n",
        "    return x * y\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "product = reduce(multiply, numbers)\n",
        "print(product)\n",
        "# Output: 120\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EFCqg1yrilei",
        "outputId": "e44bdfde-a7d3-42e4-b003-d481369de3d6"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function Documentation and Best Practices:\n"
      ],
      "metadata": {
        "id": "BF2yMY2_iniT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Purpose of Docstrings in Python Functions:\n",
        "\n",
        "Docstrings (documentation strings) in Python functions serve the purpose of providing documentation and information about the function's purpose, parameters, and usage.\n",
        "They are enclosed in triple quotes (either single or double) and can be accessed using the __doc__ attribute of a function."
      ],
      "metadata": {
        "id": "YMo0Q60Pitba"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name):\n",
        "    \"\"\"This function greets a person by their name.\"\"\"\n",
        "    return f\"Hello, {name}!\"\n"
      ],
      "metadata": {
        "id": "J-OYzCA3iw-y"
      },
      "execution_count": 100,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Docstrings are useful for:\n",
        "Providing information to developers who use the function, making it easier to understand its purpose and usage.\n",
        "Generating documentation automatically using tools like Sphinx or to generate help messages in interactive environments.\n",
        "Ensuring that other developers (and your future self) can use and maintain your code effectively.\n"
      ],
      "metadata": {
        "id": "t4UlBsgditin"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Best Practices for Naming Functions and Variables:\n",
        "\n",
        "Following best practices for naming functions and variables in Python enhances code readability and maintainability:\n",
        "\n",
        "Function Names:\n",
        "\n",
        "Use descriptive names that indicate the function's purpose and what it does.\n",
        "Use lowercase letters and separate words with underscores (snake_case).\n",
        "Follow the PEP 8 style guide for naming conventions.\n",
        "Begin function names with a verb (e.g., calculate_total(), process_data()).\n",
        "Variable Names:\n",
        "\n",
        "Use meaningful and descriptive names that convey the purpose of the variable.\n",
        "Use lowercase letters and underscores for multi-word variable names (snake_case).\n",
        "For constants, use uppercase letters with underscores (e.g., PI, MAX_VALUE).\n",
        "Be consistent in your naming conventions throughout the codebase.\n",
        "Avoid One-Letter Variable Names:\n",
        "\n",
        "Except for loop counters (e.g., i, j) and some common mathematical variables (e.g., x, y), avoid using single-letter variable names.\n",
        "Use Nouns for Variables, Verbs for Functions:\n",
        "\n",
        "Variables represent things, so use nouns for their names (e.g., user_name, total_sales).\n",
        "Functions perform actions, so use verbs for their names (e.g., calculate_total(), validate_input()).\n",
        "Follow Style Guides:\n",
        "\n",
        "Adhere to PEP 8 (Python Enhancement Proposal 8) for naming conventions and code style. This promotes consistency and readability across Python codebases."
      ],
      "metadata": {
        "id": "tW9ZC9Jqi1n2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "WR07Hxgci5V0"
      }
    }
  ]
}