Python_Functions_Part2_Assignment.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "f3226b9b-5779-4546-8422-51dd25bd4afd",
      "metadata": {
        "id": "f3226b9b-5779-4546-8422-51dd25bd4afd"
      },
      "source": [
        "# Python Full Course- Functions Advanced Assignment"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "595ebab7-1465-40ed-9d12-4aa65ac42736",
      "metadata": {
        "id": "595ebab7-1465-40ed-9d12-4aa65ac42736"
      },
      "source": [
        "**Question 1** Map and Lambda for String Operations\n",
        "\n",
        "Use the map function with a lambda to convert a list of strings ['apple', 'banana', 'cherry'] to uppercase."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0d7a6872-a0a6-48d6-84c6-59342e56ee7e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0d7a6872-a0a6-48d6-84c6-59342e56ee7e",
        "outputId": "920239bd-a434-424e-be62-7903d40ef1c4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['APPLE', 'BANANA', 'CHERRY']\n"
          ]
        }
      ],
      "source": [
        "fruits = ['apple', 'banana', 'cherry']\n",
        "# Output should be ['APPLE', 'BANANA', 'CHERRY']\n",
        "\n",
        "uppercase_fruits_list = list(map(lambda S : S.upper(), fruits))\n",
        "print(uppercase_fruits_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b0410e09-93bf-4959-be45-b090458f93f0",
      "metadata": {
        "id": "b0410e09-93bf-4959-be45-b090458f93f0"
      },
      "source": [
        "**Question 2** Filter with Lambda\n",
        "\n",
        "Use the filter function with a lambda to find all numbers in the list [10, 15, 20,24,37, 25,42, 30,57,89, 35] that are divisible by 5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a6f7639e-1039-4c3f-9ca7-12da72d45949",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a6f7639e-1039-4c3f-9ca7-12da72d45949",
        "outputId": "02717e4c-e1ad-42c8-bee9-83eab1e460fa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 15, 20, 25, 30, 35]\n"
          ]
        }
      ],
      "source": [
        "numbers = [10, 15, 20,24,37, 25,42, 30,57,89, 35]\n",
        " # Output should be [10, 15, 20, 25, 30, 35]\n",
        "\n",
        "numbers_divisible_by_5 = list(filter(lambda n : (n % 5) == 0, numbers))\n",
        "print(numbers_divisible_by_5)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "38d3dffb-c520-4856-85ac-2417ae3d4864",
      "metadata": {
        "id": "38d3dffb-c520-4856-85ac-2417ae3d4864"
      },
      "source": [
        "**Question 3** Map and Lambda for Mathematical Operations\n",
        "\n",
        "Use the map function with a lambda to add 10 to each number in the list [1, 2, 3, 4, 5]."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21dadb8c-3a8c-4266-8abc-86e744c505c0",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "21dadb8c-3a8c-4266-8abc-86e744c505c0",
        "outputId": "44c34bd2-af69-4db1-8441-cb009946173c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 12, 13, 14, 15]\n"
          ]
        }
      ],
      "source": [
        "numbers = [1, 2, 3, 4, 5]\n",
        "# Output should be [11, 12, 13, 14, 15]\n",
        "\n",
        "numbers_and_add_10 = list(map(lambda x : x + 10, numbers))\n",
        "print(numbers_and_add_10)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "81612544-e7dd-4b7b-b4e6-404c4151d7ae",
      "metadata": {
        "id": "81612544-e7dd-4b7b-b4e6-404c4151d7ae"
      },
      "source": [
        "**Question 4** Filter and Lambda for String Length\n",
        "\n",
        "Use the filter function with a lambda to filter out strings from the list ['python', 'java', 'c', 'c++'] that have length greater than 2."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4de1a226-8e2b-4f9c-b3ae-0a5710ef15d2",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4de1a226-8e2b-4f9c-b3ae-0a5710ef15d2",
        "outputId": "60566962-4ace-40f9-f571-7356f6534d56"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['python', 'java', 'c++']\n"
          ]
        }
      ],
      "source": [
        "languages = ['python', 'java', 'c', 'c++']\n",
        "# Output should be ['python', 'java', 'c++']\n",
        "\n",
        "length_of_language_greater_than_2 = list(filter(lambda a : len(a) > 2, languages))\n",
        "print(length_of_language_greater_than_2)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8d55a1ab-589d-4cd9-93ed-28a6bf899e7b",
      "metadata": {
        "id": "8d55a1ab-589d-4cd9-93ed-28a6bf899e7b"
      },
      "source": [
        "**Question 5** Map and Lambda for Squaring Numbers\n",
        "\n",
        "Use the map function with a lambda to square each number in the list [1, 2, 3, 4, 5]."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a182b964-ee0b-4eb2-9106-21fdff6e9447",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a182b964-ee0b-4eb2-9106-21fdff6e9447",
        "outputId": "68e346dc-3dca-48ea-8c80-f8bca59d7913"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ],
      "source": [
        "numbers = [1, 2, 3, 4, 5]\n",
        "# Output should be [1, 4, 9, 16, 25]\n",
        "\n",
        "square_of_numbers = list(map(lambda num : num**2, numbers))\n",
        "print(square_of_numbers)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "63459833-ca7b-40fa-be9a-cf8e18ef8039",
      "metadata": {
        "id": "63459833-ca7b-40fa-be9a-cf8e18ef8039"
      },
      "source": [
        "**Question 6** Using Reduce Function for Summation\n",
        "\n",
        "Use the reduce function from the functools module with a lambda to find the sum of all elements in the list [1, 2, 3, 4, 5]."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7664cf8d-9f40-46a5-98a8-403b4ee4b5a5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7664cf8d-9f40-46a5-98a8-403b4ee4b5a5",
        "outputId": "c420b492-3761-4bf3-9d3b-ccf700c65e2b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of all elements in [1, 2, 3, 4, 5] is 15\n"
          ]
        }
      ],
      "source": [
        "from functools import reduce\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "# Output should be 15\n",
        "\n",
        "find_sum_of_all_element_in_numbers = reduce(lambda u,v : u + v, numbers)\n",
        "print(f\"Sum of all elements in {numbers} is {find_sum_of_all_element_in_numbers}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9f6f523c-5fb9-43aa-a4ee-1a983cc0d487",
      "metadata": {
        "id": "9f6f523c-5fb9-43aa-a4ee-1a983cc0d487"
      },
      "source": [
        "**Question 7** Combining Map, Filter, and Lambda\n",
        "\n",
        "Given a list of numbers [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], first filter out the odd numbers, then square each of the remaining numbers using map, and finally sum the squared numbers using reduce."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dd3b3ea3-8ef2-41f4-bb65-f0c363e44f09",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dd3b3ea3-8ef2-41f4-bb65-f0c363e44f09",
        "outputId": "849603aa-f29b-455c-d6df-3891c219baba"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "220\n"
          ]
        }
      ],
      "source": [
        "from functools import reduce\n",
        "\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "# Output should be 220\n",
        "\n",
        "# even_nummbers_list = list(filter(lambda m: (m % 2 == 0), numbers))\n",
        "\n",
        "# square_of_even_numbers_list = list(map(lambda y : y**2, list(filter(lambda m: (m % 2 == 0), numbers))))\n",
        "\n",
        "sum_of_square_of_even_numbers = reduce(lambda i,j : i + j, list(map(lambda y : y**2, list(filter(lambda m: (m % 2 == 0), numbers)))))\n",
        "print(sum_of_square_of_even_numbers)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "71cdf06b-4ade-4fdc-b872-7f6bc7d3c606",
      "metadata": {
        "id": "71cdf06b-4ade-4fdc-b872-7f6bc7d3c606"
      },
      "source": [
        "**Question 8** Complex String Filtering and Mapping\n",
        "\n",
        "Given a list of sentences, use filter to keep only those sentences that contain the word \"Python\", and then use map to convert those sentences to lowercase."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a0730c5b-08ac-434d-bc99-bb8971fce1fc",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a0730c5b-08ac-434d-bc99-bb8971fce1fc",
        "outputId": "a0442629-b7be-4ef4-fb76-789f056945e5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['i love python', 'python is great', 'learning python is fun']\n"
          ]
        }
      ],
      "source": [
        "sentences = [\"I love Python\", \"Python is great\", \"I prefer Java\", \"JavaScript is also nice\", \"Learning Python is fun\"]\n",
        "# Output should be ['i love python', 'python is great', 'learning python is fun']\n",
        "\n",
        "# sentences_with_Python_word = list(filter(lambda l : 'Python' in l, sentences))\n",
        "\n",
        "lowercase_sentences_with_Python_word = list(map(lambda k : k.lower(), list(filter(lambda l : 'Python' in l, sentences))))\n",
        "print(lowercase_sentences_with_Python_word)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "642d641b-ddc8-4222-8010-1e94fe3e9506",
      "metadata": {
        "id": "642d641b-ddc8-4222-8010-1e94fe3e9506"
      },
      "source": [
        "**Question 9** Nested Lambda Functions with Map\n",
        "\n",
        "Use the map function with a nested lambda to multiply each number in the list [1, 2, 3, 4] by 2 and then add 3 to the result."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9ff2d3ec-dca4-444b-8054-bcec013db8f5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ff2d3ec-dca4-444b-8054-bcec013db8f5",
        "outputId": "48b2b362-c850-4ba1-c3e6-a045fcee45a1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 7, 9, 11]\n"
          ]
        }
      ],
      "source": [
        "numbers = [1, 2, 3, 4]\n",
        "# Output should be [5, 7, 9, 11]\n",
        "\n",
        "number_multiply_by_2_and_add_with_3 = list(map(lambda f : ((f * 2) + 3), numbers))\n",
        "print(number_multiply_by_2_and_add_with_3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8ff8b9e8-709b-4b89-b831-0dace2337a4d",
      "metadata": {
        "id": "8ff8b9e8-709b-4b89-b831-0dace2337a4d"
      },
      "source": [
        "**Question 10** Nested Lambda Functions with Map\n",
        "\n",
        "Use the map function with a nested lambda to multiply each number in the list [1, 2, 3, 4] by 2 and then add 3 to the result."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#same as question number 9!"
      ],
      "metadata": {
        "id": "d9zwF7NI4U5-"
      },
      "id": "d9zwF7NI4U5-",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.4"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}