Summary  
This chapter covers using lambda functions as inline predicates to filter rows based on conditional logic.

General domain of usage  
Data analysis

import unittest
import pandas as pd
import io
import sys


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 TestPandasImport(unittest.TestCase):
    def test_import_pandas_as_pd(self):
        """
        1. Import the pandas library with the pd alias.
        """
        import user_code
        condition = "pd" in user_code.__dict__ and user_code.pd is pd
        _dynamic_test(
            self,
            condition,
            "The pandas library is imported correctly with the alias 'pd'.",
            "Pandas is not imported correctly. Use 'import pandas as pd'."
        )


class TestCSVRead(unittest.TestCase):
    def test_csv_read(self):
        """
        2. Read the CSV file.
        """
        import user_code
        condition = hasattr(user_code, "data") and isinstance(user_code.data, pd.DataFrame)
        _dynamic_test(
            self,
            condition,
            "The CSV file is read correctly into the 'data' DataFrame.",
            "The CSV file is not read correctly or not assigned to 'data'."
        )


class TestEvenExtraction(unittest.TestCase):
    def test_even_rows_extraction(self):
        """
        3. Extract only rows with even indices using iloc and lambda.
        """
        import user_code
        df = user_code.data
        ref_even = df.iloc[lambda x: x.index % 2 == 0]
        condition = (
            hasattr(user_code, "even")
            and isinstance(user_code.even, pd.DataFrame)
            and user_code.even.equals(ref_even)
        )
        _dynamic_test(
            self,
            condition,
            "Rows with even indices are extracted correctly using iloc and lambda.",
            "The extraction of even-indexed rows is incorrect. Check your iloc and lambda condition."
        )


class TestOddExtraction(unittest.TestCase):
    def test_odd_rows_extraction(self):
        """
        4. Extract only rows with odd indices using iloc and lambda.
        """
        import user_code
        df = user_code.data
        ref_odd = df.iloc[lambda x: x.index % 2 != 0]
        condition = (
            hasattr(user_code, "odd")
            and isinstance(user_code.odd, pd.DataFrame)
            and user_code.odd.equals(ref_odd)
        )
        _dynamic_test(
            self,
            condition,
            "Rows with odd indices are extracted correctly using iloc and lambda.",
            "The extraction of odd-indexed rows is incorrect. Check your iloc and lambda condition."
        )


class TestOutput(unittest.TestCase):
    def test_output_print(self):
        """
        5. Output the first five even and last five odd rows.
        """
        import user_code

        captured_output = io.StringIO()
        sys.stdout = captured_output
        print(user_code.even.head(), user_code.odd.tail())
        sys.stdout = sys.__stdout__

        output_text = captured_output.getvalue().strip()
        condition = len(output_text) > 0
        _dynamic_test(
            self,
            condition,
            "The output displays the first five even and last five odd rows correctly.",
            "Output is missing. Make sure you print(even.head(), odd.tail())."
        )


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


test_code.py

Para comprobar si un índice es par o impar, utilizar el operador `%` (módulo), que devuelve el resto de una división. Si `x.index % 2 == 0`, el resto es `0`, lo que significa que el índice es par. Si `x.index % 2 != 0`, el resto es `1`, lo que significa que el índice es impar.

Nota

Para mostrar solo las primeras o últimas filas de un DataFrame, utilizar los métodos `.head(n)` y `.tail(n)`, donde `n` es el número de filas a mostrar. Por defecto, ambos métodos devuelven `5` filas si no se especifica `n`.

Este curso contiene muchas funciones útiles para un futuro analista de datos. Aprenderás diferentes formas de extraer datos e incluso establecer condiciones sobre ellos. Después de esto, estarás familiarizado con los métodos de agrupación de datos. Además, aprenderás cómo preprocesar datos. Cada sección tiene su propio conjunto de datos, lo que hace que el curso sea atractivo.

Esta sección te enseñará cómo mostrar columnas específicas por sus títulos o índices. Además, te familiarizarás con las formas en que puedes seleccionar filas por índices.

Aquí aprenderás cómo extraer datos que cumplen condiciones específicas. Además, aprenderás cómo combinarlas e incluso crear tus propias condiciones.

En esta sección, ampliarás tus conocimientos sobre cómo establecer diferentes condiciones de datos. Aprenderás a verificar si tus datos se encuentran en una lista definida de valores o entre dos valores. También aprenderás a encontrar los valores más grandes y más pequeños.

Esta sección es una de las más fascinantes del curso. Aquí aprenderás cómo agrupar datos de diferentes maneras. Te ayudará a trabajar como analista de datos para descubrir información sobre grupos de datos específicos.

Esta sección es una de las más significativas para un analista de datos porque si los datos contienen valores faltantes o en un formato incorrecto, será imposible trabajar con ellos. Por lo tanto, aquí aprenderás cómo tratar con dichos valores inapropiados.

Filtrado de Filas con Funciones Lambda

Solución