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

Ya has visto cómo las funciones de orden superior como `map` permiten aplicar una función a cada elemento de una secuencia. Otra función de orden superior esencial en Python es **`filter`**.

La función `filter` se utiliza para seleccionar elementos de una secuencia según si cumplen una determinada condición. Recibe dos argumentos: una función que devuelve `True` o `False` para cada elemento, y la secuencia a filtrar. El resultado es un iterador que contiene solo aquellos elementos para los cuales la función devuelve `True`. Esto hace que `filter` sea especialmente útil cuando se desea extraer elementos específicos de una lista, tupla u otro iterable según un criterio, como números pares, valores positivos o cadenas de cierta longitud.

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)

Este código utiliza la función `filter()` para crear una nueva lista que contiene solo los números enteros pares de una colección existente. Funciona definiendo una función predicado, `is_even(n)`. La función `filter` itera a través de la lista de números, aplicando esta comprobación a cada elemento y descartando aquellos que no cumplen la condición. Finalmente, el objeto filter resultante se convierte de nuevo en una lista, produciendo la salida.

Cuando se utiliza la función `filter`, esta devuelve un **objeto filter**, que es un iterador, no una lista. Si imprimes el resultado de `filter` directamente, verás una salida similar a:

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

Para acceder a los valores filtrados como una lista, es necesario convertir el objeto filter usando `list()`.

Nota


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

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 el procesamiento eficiente de datos.

Función Filter en Uso

Solución