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

For at kontrollere, om et indeks er lige eller ulige, bruges `%` (modulo)-operatoren – den returnerer resten af en division. Hvis `x.index % 2 == 0`, er resten `0`, hvilket betyder, at indekset er lige. Hvis `x.index % 2 != 0`, er resten `1`, hvilket betyder, at indekset er ulige.

Bemærk

For kun at vise de første eller sidste rækker i et DataFrame, bruges metoderne `.head(n)` og `.tail(n)`, hvor `n` er antallet af rækker, der skal vises. Som standard returnerer begge metoder `5` rækker, hvis `n` ikke er angivet.

Dette kursus indeholder mange nyttige funktioner for en kommende dataanalytiker. Du vil lære forskellige måder at udtrække data på og endda sætte betingelser for dem. Herefter vil du blive fortrolig med metoder til gruppering af data. Du vil også lære, hvordan man forbehandler data. Hvert afsnit har sit eget datasæt, så kurset bliver spændende.

Dette afsnit vil lære dig, hvordan du kan udtrække specifikke kolonner ved hjælp af deres titler eller indekser. Du vil også blive introduceret til måder, hvorpå du kan vælge rækker ud fra deres indekser.

Her vil du lære, hvordan man udtrækker data, der opfylder specifikke betingelser. Du vil også lære, hvordan man kombinerer dem og endda opretter dine egne.

I dette afsnit vil du udvide din viden om at opstille forskellige datakriterier. Du vil lære at kontrollere, om dine data er i en defineret liste af værdier eller mellem to værdier. Du vil også lære, hvordan du finder de største og mindste værdier.

Dette afsnit er et af de mest fascinerende i kurset. Her vil du lære, hvordan man grupperer data på forskellige måder. Det vil hjælpe dig som dataanalytiker med at finde information om specifikke datagrupper.

Dette afsnit er et af de mest betydningsfulde for en dataanalytiker, fordi det vil være umuligt at arbejde med data, hvis de indeholder manglende dataværdier i forkert format. Derfor vil du her lære, hvordan man håndterer sådanne upassende værdier.

Filtrering af Rækker med Lambda-Funktioner

Løsning