Summary  
This chapter covers using the built-in map function as a higher-order function to apply a given function to each element of an iterable, transforming data without writing explicit loops.

General domain of usage  
Data transformation


The built-in **`map`** function is a classic example of a higher-order function. It takes two arguments: a function and an iterable (such as a list). **`map`** applies the given function to each item in the iterable and returns a `map` object, which is an iterator. You can convert this object to a list to see the results. This approach is useful for transforming data efficiently without writing explicit loops.

You can use `map` with a named function like `double` to process a list of numbers: `map(double, [1, 2, 3, 4])` returns a map object that contains the doubled values. By converting the result to a list, you get `[2, 4, 6, 8]`. This demonstrates how `map` acts as a higher-order function by taking another function as its argument and applying it to each element of the iterable.

def square(x):
    return x * x

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(square, numbers))
print(squared_numbers) 

In this example, the `square` function is applied to each element in the `numbers` list. The result is a new list containing the squares of the original numbers. Notice how you did not need to write a loop — the `map` function handled the iteration for you.

You can also use `map` with built-in functions or even with anonymous functions (lambdas), which will be covered in upcoming chapters. For now, focus on how passing a function as an argument allows for flexible and reusable code transformations.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_double_numbers(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'apply_function_to_list', None)
        double = getattr(user_code, 'double', None)
        _dynamic_test(
            self,
            callable(func) and callable(double),
            "apply_function_to_list and double are defined",
            "apply_function_to_list or double not defined correctly",
        )
        result = func(double, [1, 2, 3, 4]) if func and double else None
        _dynamic_test(
            self,
            isinstance(result, list) and result == [2, 4, 6, 8],
            "Correctly doubles the numbers in the list",
            f"Expected [2, 4, 6, 8], got {result}",
        )

    def test_uppercase_strings(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'apply_function_to_list', None)
        uppercase = getattr(user_code, 'uppercase', None)
        _dynamic_test(
            self,
            callable(func) and callable(uppercase),
            "apply_function_to_list and uppercase are defined",
            "apply_function_to_list or uppercase not defined correctly",
        )
        result = func(uppercase, ["hello", "world"]) if func and uppercase else None
        _dynamic_test(
            self,
            isinstance(result, list) and result == ["HELLO", "WORLD"],
            "Correctly uppercases the strings in the list",
            f"Expected ['HELLO', 'WORLD'], got {result}",
        )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'apply_function_to_list', None)
        double = getattr(user_code, 'double', None)
        _dynamic_test(
            self,
            callable(func) and callable(double),
            "apply_function_to_list and double are defined for empty list test",
            "apply_function_to_list or double not defined correctly for empty list test",
        )
        result = func(double, []) if func and double else None
        _dynamic_test(
            self,
            isinstance(result, list) and result == [],
            "Returns an empty list when input list is empty",
            f"Expected [], got {result}",
        )

    def test_generic_function(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'apply_function_to_list', None)
        _dynamic_test(
            self,
            callable(func),
            "apply_function_to_list is defined for generic function test",
            "apply_function_to_list not defined correctly for generic function test",
        )
        def add_exclamation(x):
            return str(x) + "!"
        result = func(add_exclamation, ["a", "b", "c"]) if func else None
        _dynamic_test(
            self,
            isinstance(result, list) and result == ["a!", "b!", "c!"],
            "Works for arbitrary functions as well",
            f"Expected ['a!', 'b!', 'c!'], got {result}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

In this course, you will learn advanced topics such as function arguments, iterators, generators, closures, and decorators. Dozens of practice exercises will help you grasp these topics.

Explore the art of packing and unpacking lists, tuples, and dictionaries to write more expressive and efficient Python code.

Delve into the world of higher-order functions, passing functions as arguments, and writing concise anonymous functions with lambda.

Unravel the mysteries of variable scope, and learn how nested functions and closures enable powerful encapsulation.

Delve into Python's iteration protocol, custom iterators, and generator functions for efficient data processing.

Mastering map Function

Løsning