Summary  
This chapter introduces the use of the filter higher-order function to select elements from an iterable by applying a predicate, producing a new sequence containing only those items that satisfy a given condition.  

General domain of usage  
Data processing

Du har allerede set, hvordan højere-ordens funktioner som `map` gør det muligt at anvende en funktion på hvert element i en sekvens. En anden vigtig højere-ordens funktion i Python er **`filter`**.

Funktionen `filter` bruges til at udvælge elementer fra en sekvens baseret på, om de opfylder en bestemt betingelse. Den tager to argumenter: en funktion, der returnerer `True` eller `False` for hvert element, og den sekvens, der skal filtreres. Resultatet er en iterator, der kun indeholder de elementer, hvor funktionen returnerer `True`. Dette gør `filter` særligt nyttig, når du vil udtrække specifikke elementer fra en liste, tuple eller anden iterabel baseret på et kriterium, såsom lige tal, positive værdier eller strenge af en bestemt længde.

def is_even(n):
    return n % 2 == 0

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(is_even, numbers))
print(even_numbers)

Denne kode bruger funktionen `filter()` til at oprette en ny liste, der kun indeholder de lige heltal fra en eksisterende samling. Det fungerer ved at definere en prædikatsfunktion, `is_even(n)`. `filter`-funktionen gennemløber listen numbers, anvender denne kontrol på hvert element og udelader dem, der ikke opfylder betingelsen. Til sidst konverteres det resulterende filter-objekt tilbage til en liste, hvilket giver det viste output.

Når du bruger funktionen `filter`, returnerer den et **filter-objekt**, som er en iterator — ikke en liste. Hvis du udskriver resultatet af `filter` direkte, vil du se output, der ligner:

```
<filter object at 0xfffec885eb30>
```

For at få adgang til de filtrerede værdier som en liste, skal du konvertere filter-objektet ved hjælp af `list()`.

Bemærk


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

class TestTask(unittest.TestCase):
    def test_returns_only_positive(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.filter_positive([-3, -1, 0, 2, 4, -2])
        expected = [2, 4]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns only positive numbers from mixed list",
            f"Expected {expected}, got {result}",
        )

    def test_returns_empty_when_no_positive(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.filter_positive([-5, -1, 0, -2])
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list when no positives present",
            f"Expected {expected}, got {result}",
        )

    def test_all_positive(self):
        import user_code
        importlib.reload(user_code)
        numbers = [1, 2, 3, 4, 5]
        result = user_code.filter_positive(numbers)
        expected = [1, 2, 3, 4, 5]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns all numbers when all are positive",
            f"Expected {expected}, got {result}",
        )

    def test_all_non_positive(self):
        import user_code
        importlib.reload(user_code)
        numbers = [0, -1, -2, -3]
        result = user_code.filter_positive(numbers)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list for all non-positive input",
            f"Expected {expected}, got {result}",
        )

    def test_does_not_modify_original(self):
        import user_code
        importlib.reload(user_code)
        numbers = [-3, 0, 1, 5]
        numbers_copy = numbers[:]
        user_code.filter_positive(numbers)
        _dynamic_test(
            self,
            numbers == numbers_copy,
            "Original input list is not modified",
            f"Input list was modified: expected {numbers_copy}, got {numbers}",
        )

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

Bliv fortrolig med pakning/udpaking, fleksible funktionsargumenter, højere-ordens funktioner, lambdaer, variabelscope, closures, iteratorer og dekoratører. Udviklet til kursister, der har gennemført et introduktionskursus i Python og ønsker at skrive mere effektiv, udtryksfuld og kraftfuld kode.

Udforsk kunsten at pakke og udpakke lister, tupler og ordbøger for at skrive mere udtryksfuld og effektiv Python-kode.

Dyk ned i verdenen af højereordensfunktioner, overførsel af funktioner som argumenter og skrivning af korte anonyme funktioner med lambda.

Opdag hemmelighederne bag variabelscope, og lær hvordan indlejrede funktioner og closures muliggør effektiv indkapsling.

Dyk ned i Pythons iterationsprotokol, brugerdefinerede iteratorer og generatorfunktioner for effektiv databehandling.

Filter-Funktionen i Brug

Løsning