Supposons que vous travaillez avec un ensemble de données volumineux contenant des millions d'enregistrements, et que vous devez extraire rapidement uniquement les lignes où la valeur d'une colonne spécifique dépasse un certain seuil. Avec la bibliothèque **polars**, il est possible d'effectuer ce type de filtrage de manière efficace et à grande échelle. Il s'agit d'une exigence courante dans les **flux de travail en science des données**, en particulier lorsque l'analyse doit se concentrer sur un sous-ensemble de données répondant à certains critères.

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 cours pratique et appliqué destiné aux futurs data scientists prêts à relever les défis des grands volumes de données réels. Apprenez à traiter, échantillonner et analyser efficacement des ensembles de données massifs en utilisant Python et des bibliothèques essentielles. Chaque section propose des explications vidéo engageantes et des défis interactifs pour développer votre expertise.

Apprenez les stratégies fondamentales pour gérer des ensembles de données trop volumineux pour tenir en mémoire, y compris les techniques de découpage en blocs et de streaming.

Explorer des méthodes pour équilibrer et échantillonner de grands ensembles de données, y compris le suréchantillonnage et le sous-échantillonnage.

Apprenez à utiliser la bibliothèque Polars pour un traitement de données rapide et économe en mémoire.

Challenge: Filtrage avec Polars

Solution