Imagina que estás trabajando con un conjunto de datos masivo que contiene millones de registros y necesitas extraer rápidamente solo aquellas filas donde el valor de una columna específica supera un cierto umbral. Utilizando la biblioteca **polars**, puedes realizar este tipo de filtrado de manera eficiente y a gran escala. Este es un requisito común en los **flujos de trabajo de ciencia de datos**, especialmente cuando necesitas centrar tu análisis únicamente en un subconjunto de los datos que cumple ciertos criterios.

import unittest
import user_code
import ast
import re   
import importlib
import polars as pl

class TestTask(unittest.TestCase):
    def test_filter_basic(self):
        importlib.reload(user_code)
        df = pl.DataFrame({
            "customer_id": [1, 2, 3, 4],
            "amount": [10, 20, 30, 40]
        })
        result = user_code.filter_above_threshold(df, "amount", 20)
        expected = pl.DataFrame({"customer_id": [3, 4], "amount": [30, 40]})
        
        # FIX: Changed .frame_equal to .equals
        _dynamic_test(
            self,
            isinstance(result, pl.DataFrame) and result.equals(expected),
            "Returns rows where column value is greater than threshold.",
            f"Expected filtered DataFrame {expected}, got {result}.",
        )

    def test_does_not_modify_original(self):
        importlib.reload(user_code)
        df = pl.DataFrame({
            "a": [1, 2, 3, 4],
            "b": [10, 20, 30, 40]
        })
        df_copy = df.clone()
        _ = user_code.filter_above_threshold(df, "b", 25)
        
        # FIX: Changed .frame_equal to .equals
        _dynamic_test(
            self,
            df.equals(df_copy),
            "Original DataFrame is not modified.",
            "Original DataFrame was modified in-place.",
        )

    def test_empty_result(self):
        importlib.reload(user_code)
        df = pl.DataFrame({
            "x": [1, 2, 3],
            "y": [4, 5, 6]
        })
        result = user_code.filter_above_threshold(df, "x", 10)
        _dynamic_test(
            self,
            isinstance(result, pl.DataFrame) and result.height == 0,
            "Returns empty DataFrame if no rows match.",
            f"Expected empty DataFrame, got {result}.",
        )

    def test_any_numeric_column(self):
        importlib.reload(user_code)
        df = pl.DataFrame({
            "foo": [0.1, 0.2, 0.3, 0.4],
            "bar": [5, 10, 15, 20]
        })
        result = user_code.filter_above_threshold(df, "foo", 0.25)
        expected = pl.DataFrame({"foo": [0.3, 0.4], "bar": [15, 20]})
        
        # FIX: Changed .frame_equal to .equals
        _dynamic_test(
            self,
            isinstance(result, pl.DataFrame) and result.equals(expected),
            "Works with any valid numeric column.",
            f"Expected {expected}, 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)

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

test_main.py

Un curso práctico y orientado a la acción para aspirantes a científicos de datos preparados para enfrentar desafíos reales con grandes volúmenes de datos. Aprenda a procesar, muestrear y analizar conjuntos de datos masivos de manera eficiente utilizando Python y bibliotecas esenciales. Cada sección incluye explicaciones en video atractivas y desafíos interactivos para desarrollar su experiencia.

Aprende estrategias fundamentales para manejar conjuntos de datos demasiado grandes para caber en la memoria, incluyendo técnicas de particionado y transmisión.

Explora métodos para equilibrar y muestrear grandes conjuntos de datos, incluyendo el sobremuestreo y el submuestreo.

Aprende a utilizar la biblioteca Polars para un procesamiento de datos rápido y eficiente en memoria.

Desafío: Filtrado con Polars

Solución