Summary  
This chapter explains how to use the built-in `map` function as a higher-order function to apply a given function to each element of an iterable, producing a new transformed collection without explicit loops.

General domain of usage  
Data transformation

### Funktionen map i Python

Den inbyggda **`map`**-funktionen är ett klassiskt exempel på en högre ordningens funktion. Den tar två argument: en funktion och en itererbar (till exempel en lista). **`map`** applicerar den angivna funktionen på varje element i den itererbara och returnerar ett `map`-objekt, vilket är en iterator. Du kan konvertera detta objekt till en lista för att se resultaten. Detta tillvägagångssätt är användbart för att effektivt transformera data utan att skriva explicita loopar.

Du kan använda `map` med en namngiven funktion som `double` för att bearbeta en lista med tal: `map(double, [1, 2, 3, 4])` returnerar ett map-objekt som innehåller de dubblerade värdena. Genom att konvertera resultatet till en lista får du `[2, 4, 6, 8]`. Detta visar hur `map` fungerar som en högre ordningens funktion genom att ta en annan funktion som argument och applicera den på varje element i den itererbara.

def square(x):
    return x * x

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

I detta exempel appliceras funktionen `square` på varje element i listan `numbers`. Resultatet är en ny lista som innehåller kvadraterna av de ursprungliga talen. Observera att du inte behövde skriva en loop — funktionen `map` hanterade iterationen åt dig.

Du kan också använda `map` med inbyggda funktioner eller till och med med anonyma funktioner (lambdas), vilket kommer att behandlas i kommande kapitel. Fokusera för närvarande på hur det går att skicka en funktion som argument för att möjliggöra flexibla och återanvändbara kodtransformationer.


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

Bemästra packning/uppackning, flexibla funktionsargument, högre ordningens funktioner, lambdas, variabelräckvidd, closures, iteratorer och dekoratörer. Utformad för studenter som har genomfört en introduktionskurs i Python och vill skriva mer effektiv, uttrycksfull och kraftfull kod.

Utforska konsten att packa och packa upp listor, tupler och ordböcker för att skriva mer uttrycksfull och effektiv Python-kod.

Fördjupa dig i världen av högre ordningens funktioner, att skicka funktioner som argument och att skriva koncisa anonyma funktioner med lambda.

Avslöja mysterierna kring variabelns räckvidd och lär dig hur nästlade funktioner och closures möjliggör kraftfull inkapsling.

Fördjupa dig i Pythons iterationsprotokoll, anpassade iteratorer och generatorfunktioner för effektiv databehandling.

Bemästra Map-funktionen

Funktionen map i Python

Lösning