Summary  
This chapter introduces the map function as a higher-order function that applies a given function to each element of an iterable, producing a new collection of transformed data without explicit loops.

General domain of usage  
Data transformation

### La función map en Python

La función incorporada **`map`** es un ejemplo clásico de función de orden superior. Recibe dos argumentos: una función y un iterable (como una lista). **`map`** aplica la función proporcionada a cada elemento del iterable y devuelve un objeto `map`, que es un iterador. Puedes convertir este objeto en una lista para ver los resultados. Este enfoque es útil para transformar datos de manera eficiente sin escribir bucles explícitos.

Puedes usar `map` con una función nombrada como `double` para procesar una lista de números: `map(double, [1, 2, 3, 4])` devuelve un objeto map que contiene los valores duplicados. Al convertir el resultado en una lista, obtienes `[2, 4, 6, 8]`. Esto demuestra cómo `map` actúa como una función de orden superior al recibir otra función como argumento y aplicarla a cada elemento del iterable.

def square(x):
    return x * x

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

En este ejemplo, la función `square` se aplica a cada elemento de la lista `numbers`. El resultado es una nueva lista que contiene los cuadrados de los números originales. Observa que no fue necesario escribir un bucle: la función `map` se encargó de la iteración.

También puedes usar `map` con funciones incorporadas o incluso con funciones anónimas (lambdas), que se tratarán en los próximos capítulos. Por ahora, concéntrate en cómo pasar una función como argumento permite realizar transformaciones de código flexibles y reutilizables.


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

Domina el empaquetado/desempaquetado, argumentos flexibles en funciones, funciones de orden superior, lambdas, alcance de variables, closures, iteradores y decoradores. Diseñado para estudiantes que han completado un curso introductorio de Python y desean escribir código más eficiente, expresivo y potente.

Explora el arte de empaquetar y desempaquetar listas, tuplas y diccionarios para escribir código Python más expresivo y eficiente.

Adentrarse en el mundo de las funciones de orden superior, el paso de funciones como argumentos y la escritura de funciones anónimas concisas con lambda.

Descubre los misterios del alcance de las variables y aprende cómo las funciones anidadas y los closures permiten una encapsulación poderosa.

Profundización en el protocolo de iteración de Python, iteradores personalizados y funciones generadoras para un procesamiento de datos eficiente.

Dominar la Función Map

La función map en Python

Solución