import unittest
import importlib
import pandas as pd
import seaborn as sns

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestTitanicCleaning(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """Import user's solution and prepare reference data for testing."""
        cls.user_code = importlib.import_module("user_code")
        cls.cleaned = cls.user_code.cleaned_data

        # Load base dataset to compute IQR bounds for reference
        base = sns.load_dataset("titanic")
        base["age"].fillna(base["age"].mean(), inplace=True)
        base["embarked"].fillna(base["embarked"].mode()[0], inplace=True)
        base.drop_duplicates(inplace=True)

        Q1 = base["fare"].quantile(0.25)
        Q3 = base["fare"].quantile(0.75)
        IQR = Q3 - Q1
        cls.lower_bound = Q1 - 1.5 * IQR
        cls.upper_bound = Q3 + 1.5 * IQR

    def test_no_missing_values(self):
        """Ensure missing values in 'age' and 'embarked' are handled."""
        df = self.cleaned
        condition = (
            not df["age"].isnull().any() and
            not df["embarked"].isnull().any()
        )
        _dynamic_test(
            self,
            condition,
            "No missing values remain in 'age' or 'embarked'.",
            "Missing values still exist in 'age' or 'embarked'."
        )

    def test_no_duplicates(self):
        """Ensure duplicate rows are removed."""
        df = self.cleaned
        condition = len(df) == len(df.drop_duplicates())
        _dynamic_test(
            self,
            condition,
            "Duplicate rows successfully removed.",
            "Duplicate rows still exist in the dataset."
        )

    def test_outlier_removal(self):
        """Verify that outliers in 'fare' were filtered using IQR."""
        df = self.cleaned.copy()
        fares = df["fare"].dropna()
        eps = 1e-6
        within = fares.between(self.lower_bound - eps, self.upper_bound + eps)
        condition = within.all()
        _dynamic_test(
            self,
            condition,
            "Outliers in 'fare' handled correctly using IQR.",
            "Some extreme 'fare' values were not properly filtered."
        )

    def test_columns_exist(self):
        """Ensure required columns exist in the cleaned dataset."""
        required = {"age", "embarked", "fare"}
        df_cols = set(self.cleaned.columns)
        condition = required.issubset(df_cols)
        _dynamic_test(
            self,
            condition,
            "Cleaned dataset includes essential columns.",
            "One or more essential columns are missing in the cleaned dataset."
        )

if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)


test_code.py

Aprende técnicas prácticas para limpiar, transformar y diseñar datos para aprendizaje automático utilizando Python. Este curso abarca pasos esenciales de preprocesamiento, creación de características y desafíos prácticos para preparar los datos para la modelización.

Domina los pasos fundamentales para limpiar y preparar datos en bruto para análisis y aprendizaje automático.

Transformación de datos sin procesar en características utilizables para modelos de aprendizaje automático.

Ingeniería y selección de características para mejorar el rendimiento y la interpretabilidad del modelo.

Desafío: Limpieza de Datos

Solución