function_assignment_module_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "Vf2uPawwnkfz"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Theory Questions"
      ],
      "metadata": {
        "id": "Vf2uPawwnkfz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 1. What is the difference between a function and a method in Python?\n"
      ],
      "metadata": {
        "id": "cJSDkOJbuVMl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The primary difference between a function and a method in Python lies in how they are associated with objects and how they are called:\n",
        "\n",
        "Function:\n",
        "\n",
        "A function is a block of code that performs a specific task and is defined using the def keyword.\n",
        "It is not tied to any particular object and can be called independently.\n",
        "\n",
        "Method:\n",
        "\n",
        "A method is a function that is associated with an object.\n",
        "It is called on an object and can access the object's attributes and other methods.\n",
        "Methods are defined within a class and take the instance (self) as their first parameter."
      ],
      "metadata": {
        "id": "pxSBv5XTnog9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Explain the concept of function arguments and parameters in Python."
      ],
      "metadata": {
        "id": "GvrTOLFhud4R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, arguments and parameters are essential concepts related to passing data to functions.\n",
        "\n",
        "Parameters:\n",
        "\n",
        "These are the placeholders or variables defined in the function header (within the parentheses) when a function is declared.\n",
        "They act as inputs that the function expects to receive when it is called.\n",
        "\n",
        "Arguments:\n",
        "\n",
        "These are the actual values passed to the function when it is called.\n",
        "They fill the placeholders (parameters) and provide the function with the necessary data.\n"
      ],
      "metadata": {
        "id": "FS0bMrUIqWB6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. What are the different ways to define and call a function in Python?"
      ],
      "metadata": {
        "id": "lbfdQOKKughy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "**Different ways to define functions in Python:**\n",
        "\n",
        "- **Regular Function**  \n",
        "  Defined using the `def` keyword.  \n",
        "  ```python\n",
        "  def greet(name):\n",
        "      return f\"Hello, {name}!\"\n",
        "  ```\n",
        "\n",
        "- **Lambda Function**  \n",
        "  A single-expression anonymous function defined using the `lambda` keyword.  \n",
        "  ```python\n",
        "  square = lambda x: x ** 2\n",
        "  ```\n",
        "\n",
        "- **Function with Default Arguments**  \n",
        "  Parameters can have default values.  \n",
        "  ```python\n",
        "  def greet_default(name=\"Guest\"):\n",
        "      return f\"Hello, {name}!\"\n",
        "  ```\n",
        "\n",
        "- **Function with Variable-Length Arguments**  \n",
        "  Use `*args` for positional arguments and `**kwargs` for keyword arguments.  \n",
        "  ```python\n",
        "  def describe_person(*args, **kwargs):\n",
        "      print(\"Positional arguments:\", args)\n",
        "      print(\"Keyword arguments:\", kwargs)\n",
        "  ```\n",
        "\n",
        "- **Nested Function**  \n",
        "  Functions can be defined inside other functions.  \n",
        "  ```python\n",
        "  def outer_function():\n",
        "      def inner_function():\n",
        "          return \"Hello from inner function!\"\n",
        "      return inner_function()\n",
        "  ```\n",
        "\n",
        "- **Recursive Function**  \n",
        "  A function can call itself until a base condition is reached.  \n",
        "  ```python\n",
        "  def factorial(n):\n",
        "      return 1 if n == 0 else n * factorial(n - 1)\n",
        "  ```\n",
        "\n",
        "- **Class Method**  \n",
        "  Functions defined in a class operate on its instances.  \n",
        "  ```python\n",
        "  class Greeter:\n",
        "      def greet(self, name):\n",
        "          return f\"Hello, {name}!\"\n",
        "  ```\n",
        "\n",
        "---\n",
        "\n",
        "**Different ways to call functions in Python:**\n",
        "\n",
        "- **Regular Function Call**  \n",
        "  Call by passing arguments.  \n",
        "  ```python\n",
        "  print(greet(\"Arbaz\"))  # Output: Hello, Arbaz!\n",
        "  ```\n",
        "\n",
        "- **Lambda Function Call**  \n",
        "  Call directly or through a variable.  \n",
        "  ```python\n",
        "  print(square(5))  # Output: 25\n",
        "  ```\n",
        "\n",
        "- **Calling Functions with Default Arguments**  \n",
        "  Call without or with arguments.  \n",
        "  ```python\n",
        "  print(greet_default())       # Output: Hello, Guest!\n",
        "  print(greet_default(\"Arbaz\"))  # Output: Hello, Arbaz!\n",
        "  ```\n",
        "\n",
        "- **Calling Functions with Variable-Length Arguments**  \n",
        "  Pass any number of arguments.  \n",
        "  ```python\n",
        "  describe_person(25, \"Arbaz\", city=\"Mumbai\", hobby=\"coding\")\n",
        "  # Output:\n",
        "  # Positional arguments: (25, 'Arbaz')\n",
        "  # Keyword arguments: {'city': 'Mumbai', 'hobby': 'coding'}\n",
        "  ```\n",
        "\n",
        "- **Calling Nested Functions**  \n",
        "  Call the outer function, which invokes the inner function.  \n",
        "  ```python\n",
        "  print(outer_function())  # Output: Hello from inner function!\n",
        "  ```\n",
        "\n",
        "- **Calling Recursive Functions**  \n",
        "  Pass the base case and observe recursive behavior.  \n",
        "  ```python\n",
        "  print(factorial(5))  # Output: 120\n",
        "  ```\n",
        "\n",
        "- **Calling Class Methods**  \n",
        "  Create an instance of the class and call its method.  \n",
        "  ```python\n",
        "  obj = Greeter()\n",
        "  print(obj.greet(\"Arbaz\"))  # Output: Hello, Arbaz!\n",
        "  ```\n",
        "\n"
      ],
      "metadata": {
        "id": "ewO0QghKujis"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 4. What is the purpose of the `return` statement in a Python function?\n"
      ],
      "metadata": {
        "id": "Vp7gzPcGxkP8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The return statement in a Python function is used to specify the value that the function will output when called, allowing the returned value to be stored in variables or used in further operations. It also terminates the execution of the function, ensuring any code written after the return statement is not executed. Additionally, it enables returning multiple values, typically as a tuple, which can be unpacked into separate variables. If a return statement is used without any value, or if it is omitted entirely, the function implicitly returns None. This makes the return statement a vital part of function behavior, enabling communication between a function and the rest of the program."
      ],
      "metadata": {
        "id": "eAQMDhmIxojU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 5. What are iterators in Python and how do they differ from iterables?\n"
      ],
      "metadata": {
        "id": "62CNMEwjwlz5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Key Differences:\n",
        "\n",
        "\n",
        "*Iterable*: An object that can return an iterator when iter() is called. It can be any collection, like a list or a tuple.\n",
        "\n",
        "\n",
        "*Iterator*: An object that keeps track of its current position and can be traversed using next().\n",
        "\n",
        "\n",
        "In Python, iterators are objects that allow you to traverse through all the elements of a collection, such as a list, tuple, or string, one by one. An iterator implements two main methods:\n",
        "\n",
        "__iter__(): This method returns the iterator object itself.\n",
        "__next__(): This method returns the next item from the collection. If there are no more items, it raises the StopIteration exception, signaling that the iteration is complete."
      ],
      "metadata": {
        "id": "qnxzMmxTyP3S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 6. Explain the concept of generators in Python and how they are defined."
      ],
      "metadata": {
        "id": "08-d75TgyhsE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Generators in Python are a type of iterable, like lists or tuples, but they allow you to generate values on the fly and are more memory-efficient. Unlike lists, which store all their elements in memory, generators generate one item at a time as you iterate over them, which makes them ideal for large datasets or streams of data.\n",
        "\n",
        "A generator is defined using a function with the yield keyword. The yield statement returns a value from the generator function but does not terminate the function. The state of the function is saved, so when the generator is called again, it resumes from where it left off, continuing the iteration."
      ],
      "metadata": {
        "id": "nzr7cnzrzJkP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 7. What are the advantages of using generators over regular functions?\n"
      ],
      "metadata": {
        "id": "3PsavzaqzTI3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Generators offer several advantages over regular functions, especially when dealing with large data sets or streams of data. Some key advantages include:\n",
        "\n",
        "Memory Efficiency: Generators yield one item at a time and do not store the entire sequence in memory. This makes them highly efficient for working with large datasets or infinite sequences, as they only generate values on demand.\n",
        "\n",
        "Example: A list containing 1 million numbers would require significant memory, but a generator would only generate one number at a time, reducing memory usage.\n",
        "\n",
        "Lazy Evaluation: Generators use lazy evaluation, meaning they generate values only when they are needed. This can be beneficial when processing large amounts of data, as you avoid the overhead of generating and storing the entire dataset at once.\n",
        "\n",
        "Example: When processing large logs or data from a stream, you can start consuming the data immediately without waiting for the entire set to be processed.\n",
        "\n",
        "Improved Performance: Since generators produce values one at a time, they can improve performance in cases where the entire dataset is not needed or where the computation of each value is independent. Regular functions return all values at once, which can be slower and more resource-intensive."
      ],
      "metadata": {
        "id": "rukER0i5zlSF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 8. What is a lambda function in Python and when is it typically used?"
      ],
      "metadata": {
        "id": "MsOKkieAzxGR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A lambda function in Python is an anonymous, small, and single-expression function defined using the lambda keyword. Unlike regular functions defined with the def keyword, lambda functions are typically used for short-term tasks where a full function definition is unnecessary.\n",
        "\n",
        "Syntax:\n",
        "\n",
        "lambda arguments: expression\n",
        "arguments: The parameters that the lambda function takes (just like a regular function).\n",
        "expression: A single expression that is evaluated and returned. The result of this expression is the return value of the lambda function"
      ],
      "metadata": {
        "id": "ZsVLDnriz97R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " 9. Explain the purpose and usage of the `map()` function in Python.\n"
      ],
      "metadata": {
        "id": "FMbYKpzF0DF-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The map() function in Python is used to apply a given function to all items in an iterable (like a list, tuple, or other sequence) and returns a map object (an iterator) that produces the results. It is typically used to perform the same operation on each element of a sequence.\n",
        "\n",
        "Syntax:\n",
        "python\n",
        "Copy code\n",
        "map(function, iterable, ...)"
      ],
      "metadata": {
        "id": "0PX89XhA0Lsy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "10. What is the difference between `map()`, `reduce()`, and `filter()` functions in Python?"
      ],
      "metadata": {
        "id": "aAJT6Iwu1yJK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **`map()`**: The `map()` function applies a given function to each item of an iterable (e.g., a list or tuple) and returns an iterator with the results. It can also take multiple iterables and apply the function to elements at corresponding positions.  \n",
        "  Example: Squaring each number in a list.  \n",
        "  ```python\n",
        "  numbers = [1, 2, 3, 4]\n",
        "  result = map(lambda x: x ** 2, numbers)  \n",
        "  print(list(result))  # Output: [1, 4, 9, 16]\n",
        "  ```\n",
        "\n",
        "- **`reduce()`**: The `reduce()` function, from the `functools` module, takes a function and applies it cumulatively to the items of an iterable, reducing it to a single value. It processes the iterable two elements at a time, applying the function to the first two, then the result with the next, and so on.  \n",
        "  Example: Finding the product of all numbers in a list.  \n",
        "  ```python\n",
        "  from functools import reduce\n",
        "  numbers = [1, 2, 3, 4]\n",
        "  result = reduce(lambda x, y: x * y, numbers)  \n",
        "  print(result)  # Output: 24 (1 * 2 * 3 * 4)\n",
        "  ```\n",
        "\n",
        "- **`filter()`**: The `filter()` function filters elements from an iterable based on a condition defined in a function. It returns an iterator containing only those elements for which the function returns `True`.  \n",
        "  Example: Selecting even numbers from a list.  \n",
        "  ```python\n",
        "  numbers = [1, 2, 3, 4, 5, 6]\n",
        "  result = filter(lambda x: x % 2 == 0, numbers)  \n",
        "  print(list(result))  # Output: [2, 4, 6]\n",
        "  ```\n",
        "\n",
        "### Summary:\n",
        "- `map()` transforms items in an iterable.\n",
        "- `reduce()` reduces an iterable to a single value.\n",
        "- `filter()` selects items from an iterable based on a condition."
      ],
      "metadata": {
        "id": "6m2NYksE1PCh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "11. Using pen & Paper write the internal mechanism for sum operation using  reduce function on this given list:[47,11,42,13];"
      ],
      "metadata": {
        "id": "qG9y4KWT1uI0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![WhatsApp Image 2024-12-22 at 21.35.32_b8dad4cb.jpg](data:image/jpeg;base64,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)\n",
        "\n",
        "\n",
        "The reduce() function processes the list [47, 11, 42, 13] by repeatedly applying the given add function to pairs of elements. It starts with the first two elements, 47 and 11, and calculates their sum, yielding 58. This result is then combined with the next element, 42, resulting in 100. Finally, the accumulated result, 100, is added to the last element, 13, producing the final sum of 113. The process continues until the list is reduced to a single value, demonstrating how reduce() iteratively applies the function to combine all elements in the list into one result."
      ],
      "metadata": {
        "id": "WwSYfrAZ18wp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Practical Questions"
      ],
      "metadata": {
        "id": "F7-BiWPy8mij"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Write a Python function that takes a list of numbers as input and returns the sum of all even numbers in\n",
        "the list."
      ],
      "metadata": {
        "id": "PKBarAkQ8w5I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sump(lists):\n",
        "\n",
        "  s=0\n",
        "  for i in lists:\n",
        "    if i%2==0:\n",
        "      s=s+i\n",
        "  return s\n",
        "\n",
        "\n",
        "print(sump([1,2,3,4,10]))"
      ],
      "metadata": {
        "id": "rCdg4N9PuxYR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f593b7b-6b81-45cd-e61c-56210c7b8980"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 2. Create a Python function that accepts a string and returns the reverse of that string."
      ],
      "metadata": {
        "id": "X9sFa64Q-WLn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def reverse(strings):\n",
        "  return strings[::-1]\n",
        "\n",
        "print(reverse(\"Arbaz\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cw9IM2OG-TiC",
        "outputId": "466f068f-225c-4f97-e1c9-eeb9944d9a46"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "zabrA\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 3. Implement a Python function that takes a list of integers and returns a new list containing the squares of\n",
        "each number."
      ],
      "metadata": {
        "id": "Z1Yw8oyU-mmu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sqlist =lambda l: [i**2 for i in l]\n",
        "listn=[1,2,3,4,5]\n",
        "print(sqlist(listn))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HwB4s0md-uZd",
        "outputId": "d4fafc0d-bb68-41ae-a380-218f5769ce21"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 4. Write a Python function that checks if a given number is prime or not from 1 to 200."
      ],
      "metadata": {
        "id": "liYMHS1q-qnO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_prime(n):\n",
        "    if n == 1:\n",
        "        return f\"{n} is neither a prime nor composite\"\n",
        "    elif n <1:\n",
        "      return \"{} not a valid number to check\",format(n)\n",
        "    for i in range(2, int(n**0.5) + 1):\n",
        "        if n % i == 0:\n",
        "            return f\"{n} is not a prime\"\n",
        "    return f\"{n} is a prime\"\n",
        "\n",
        "# Test the function with numbers from 1 to 200\n",
        "for number in range(1, 201):\n",
        "    print(is_prime(number))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uY7fmETZ_RRM",
        "outputId": "6bd9da3a-848f-4de8-990f-72f99d79e7fc"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 is not a prime nor composite\n",
            "2 is a prime\n",
            "3 is a prime\n",
            "4 is not a prime\n",
            "5 is a prime\n",
            "6 is not a prime\n",
            "7 is a prime\n",
            "8 is not a prime\n",
            "9 is not a prime\n",
            "10 is not a prime\n",
            "11 is a prime\n",
            "12 is not a prime\n",
            "13 is a prime\n",
            "14 is not a prime\n",
            "15 is not a prime\n",
            "16 is not a prime\n",
            "17 is a prime\n",
            "18 is not a prime\n",
            "19 is a prime\n",
            "20 is not a prime\n",
            "21 is not a prime\n",
            "22 is not a prime\n",
            "23 is a prime\n",
            "24 is not a prime\n",
            "25 is not a prime\n",
            "26 is not a prime\n",
            "27 is not a prime\n",
            "28 is not a prime\n",
            "29 is a prime\n",
            "30 is not a prime\n",
            "31 is a prime\n",
            "32 is not a prime\n",
            "33 is not a prime\n",
            "34 is not a prime\n",
            "35 is not a prime\n",
            "36 is not a prime\n",
            "37 is a prime\n",
            "38 is not a prime\n",
            "39 is not a prime\n",
            "40 is not a prime\n",
            "41 is a prime\n",
            "42 is not a prime\n",
            "43 is a prime\n",
            "44 is not a prime\n",
            "45 is not a prime\n",
            "46 is not a prime\n",
            "47 is a prime\n",
            "48 is not a prime\n",
            "49 is not a prime\n",
            "50 is not a prime\n",
            "51 is not a prime\n",
            "52 is not a prime\n",
            "53 is a prime\n",
            "54 is not a prime\n",
            "55 is not a prime\n",
            "56 is not a prime\n",
            "57 is not a prime\n",
            "58 is not a prime\n",
            "59 is a prime\n",
            "60 is not a prime\n",
            "61 is a prime\n",
            "62 is not a prime\n",
            "63 is not a prime\n",
            "64 is not a prime\n",
            "65 is not a prime\n",
            "66 is not a prime\n",
            "67 is a prime\n",
            "68 is not a prime\n",
            "69 is not a prime\n",
            "70 is not a prime\n",
            "71 is a prime\n",
            "72 is not a prime\n",
            "73 is a prime\n",
            "74 is not a prime\n",
            "75 is not a prime\n",
            "76 is not a prime\n",
            "77 is not a prime\n",
            "78 is not a prime\n",
            "79 is a prime\n",
            "80 is not a prime\n",
            "81 is not a prime\n",
            "82 is not a prime\n",
            "83 is a prime\n",
            "84 is not a prime\n",
            "85 is not a prime\n",
            "86 is not a prime\n",
            "87 is not a prime\n",
            "88 is not a prime\n",
            "89 is a prime\n",
            "90 is not a prime\n",
            "91 is not a prime\n",
            "92 is not a prime\n",
            "93 is not a prime\n",
            "94 is not a prime\n",
            "95 is not a prime\n",
            "96 is not a prime\n",
            "97 is a prime\n",
            "98 is not a prime\n",
            "99 is not a prime\n",
            "100 is not a prime\n",
            "101 is a prime\n",
            "102 is not a prime\n",
            "103 is a prime\n",
            "104 is not a prime\n",
            "105 is not a prime\n",
            "106 is not a prime\n",
            "107 is a prime\n",
            "108 is not a prime\n",
            "109 is a prime\n",
            "110 is not a prime\n",
            "111 is not a prime\n",
            "112 is not a prime\n",
            "113 is a prime\n",
            "114 is not a prime\n",
            "115 is not a prime\n",
            "116 is not a prime\n",
            "117 is not a prime\n",
            "118 is not a prime\n",
            "119 is not a prime\n",
            "120 is not a prime\n",
            "121 is not a prime\n",
            "122 is not a prime\n",
            "123 is not a prime\n",
            "124 is not a prime\n",
            "125 is not a prime\n",
            "126 is not a prime\n",
            "127 is a prime\n",
            "128 is not a prime\n",
            "129 is not a prime\n",
            "130 is not a prime\n",
            "131 is a prime\n",
            "132 is not a prime\n",
            "133 is not a prime\n",
            "134 is not a prime\n",
            "135 is not a prime\n",
            "136 is not a prime\n",
            "137 is a prime\n",
            "138 is not a prime\n",
            "139 is a prime\n",
            "140 is not a prime\n",
            "141 is not a prime\n",
            "142 is not a prime\n",
            "143 is not a prime\n",
            "144 is not a prime\n",
            "145 is not a prime\n",
            "146 is not a prime\n",
            "147 is not a prime\n",
            "148 is not a prime\n",
            "149 is a prime\n",
            "150 is not a prime\n",
            "151 is a prime\n",
            "152 is not a prime\n",
            "153 is not a prime\n",
            "154 is not a prime\n",
            "155 is not a prime\n",
            "156 is not a prime\n",
            "157 is a prime\n",
            "158 is not a prime\n",
            "159 is not a prime\n",
            "160 is not a prime\n",
            "161 is not a prime\n",
            "162 is not a prime\n",
            "163 is a prime\n",
            "164 is not a prime\n",
            "165 is not a prime\n",
            "166 is not a prime\n",
            "167 is a prime\n",
            "168 is not a prime\n",
            "169 is not a prime\n",
            "170 is not a prime\n",
            "171 is not a prime\n",
            "172 is not a prime\n",
            "173 is a prime\n",
            "174 is not a prime\n",
            "175 is not a prime\n",
            "176 is not a prime\n",
            "177 is not a prime\n",
            "178 is not a prime\n",
            "179 is a prime\n",
            "180 is not a prime\n",
            "181 is a prime\n",
            "182 is not a prime\n",
            "183 is not a prime\n",
            "184 is not a prime\n",
            "185 is not a prime\n",
            "186 is not a prime\n",
            "187 is not a prime\n",
            "188 is not a prime\n",
            "189 is not a prime\n",
            "190 is not a prime\n",
            "191 is a prime\n",
            "192 is not a prime\n",
            "193 is a prime\n",
            "194 is not a prime\n",
            "195 is not a prime\n",
            "196 is not a prime\n",
            "197 is a prime\n",
            "198 is not a prime\n",
            "199 is a prime\n",
            "200 is not a prime\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 5. Create an iterator class in Python that generates the Fibonacci sequence up to a specified number of\n",
        "terms"
      ],
      "metadata": {
        "id": "spp5DzGcC1AS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FibonacciIterator:\n",
        "    def __init__(self, n):\n",
        "        self.n = n\n",
        "        self.a, self.b = 0, 1\n",
        "\n",
        "    def __iter__(self):\n",
        "        return self\n",
        "\n",
        "    def __next__(self):\n",
        "        if self.n <= 0:\n",
        "            raise StopIteration\n",
        "        current = self.a\n",
        "        self.a, self.b = self.b, self.a + self.b\n",
        "        self.n -= 1\n",
        "        return current\n",
        "\n",
        "fibonacci_sequence = FibonacciIterator(10)\n",
        "for num in fibonacci_sequence:\n",
        "    print(num)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LRs9BWOaC_M_",
        "outputId": "025fc712-b30f-4d65-dad9-8c0980cfef7e"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 6. Write a generator function in Python that yields the powers of 2 up to a given exponent."
      ],
      "metadata": {
        "id": "Vk_wY3R8C2O7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def pot(h_p):\n",
        "  p=0\n",
        "  while(p<=h_p):\n",
        "    yield 2**p\n",
        "    p=p+1\n",
        "\n",
        "\n",
        "\n",
        "for i in pot(5):\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h5tfIiIuCoAS",
        "outputId": "01cdc816-2ea7-4fc6-bb7e-37d2fd077e02"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "4\n",
            "8\n",
            "16\n",
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. Implement a generator function that reads a file line by line and yields each line as a string."
      ],
      "metadata": {
        "id": "wxuwccZqSuRV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "file_content = [\n",
        "    \"Hello, this is the first line.\",\n",
        "    \"This is the second line.\",\n",
        "    \"And this is the third line.\",\n",
        "    \"This is the fourth line.\",\n",
        "]\n",
        "\n",
        "\n",
        "def read_file_line_by_line(content):\n",
        "    for line in content:\n",
        "        yield line.strip()\n",
        "\n",
        "\n",
        "for line in read_file_line_by_line(file_content):\n",
        "    print(line)\n"
      ],
      "metadata": {
        "id": "AFQ849ZwPK4B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " 8. Use a lambda function in Python to sort a list of tuples based on the second element of each tuple."
      ],
      "metadata": {
        "id": "AGngQOwQSzMs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuples_list = [(1, 3), (6, 1), (5, 2), (4, 4)]\n",
        "sorted_list = sorted(tuples_list, key=lambda x: x[1])\n",
        "print(sorted_list)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N7Dr3Zt9S5dV",
        "outputId": "0cacbb90-a7d0-46cb-a3f9-7ecc037f6afe"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(6, 1), (5, 2), (1, 3), (4, 4)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 9. Write a Python program that uses `map()` to convert a list of temperatures from Celsius to Fahrenheit."
      ],
      "metadata": {
        "id": "JVmgCWTSTEbr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "celsius_temperatures = [30,45,32,25]\n",
        "def celsius_to_fahrenheit(celsius):\n",
        "    return (celsius * 9/5) + 32\n",
        "fahrenheit_temperatures = list(map(celsius_to_fahrenheit, celsius_temperatures))\n",
        "\n",
        "print(fahrenheit_temperatures)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_IWc5BkWTJdr",
        "outputId": "32874181-c39c-4dc5-8bc1-80834e6664c8"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[86.0, 113.0, 89.6, 77.0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 10. Create a Python program that uses `filter()` to remove all the vowels from a given string."
      ],
      "metadata": {
        "id": "Sqw28-B9TTNX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_not_vowel(char):\n",
        "    return char.lower() not in 'aeiou'\n",
        "input_string = \"Hello, World!\"\n",
        "filtered_string = ''.join(filter(is_not_vowel, input_string))\n",
        "\n",
        "print(filtered_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NBWJTd7JTOlq",
        "outputId": "c139e243-1beb-4ba1-bc5e-9b52d55a9637"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hll, Wrld!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " 11) Imagine an accounting routine used in a book shop. It works on a list with sublists, which look like this:\n",
        " Write a Python program, which returns a list with 2-tuples. Each tuple consists of the order number and the\n",
        "product of the price per item and the quantity. The product should be increased by 10,- € if the value of the\n",
        "order is smaller than 100,00 €.\n",
        " Write a Python program using lambda and map"
      ],
      "metadata": {
        "id": "O-LVadl4Taas"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "orders = [\n",
        "    [101, 4,40.00],\n",
        "    [202, 5, 56.80],\n",
        "    [302, 3, 32.95],\n",
        "    [402, 3, 24.99],\n",
        "]\n",
        "def calculate_order(order):\n",
        "    order_number, price_per_item, quantity = order\n",
        "    total_price = price_per_item * quantity\n",
        "    if total_price < 100:\n",
        "        total_price += 10\n",
        "    return (order_number, total_price)\n",
        "result = list(map(lambda order: calculate_order(order), orders))\n",
        "\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xl5VTn9BTmc-",
        "outputId": "34d130c7-8a18-4312-8597-cedf778d17c8"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(101, 160.0), (202, 284.0), (302, 108.85000000000001), (402, 84.97)]\n"
          ]
        }
      ]
    }
  ]
}