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

Um zu überprüfen, ob ein Index gerade oder ungerade ist, verwende den `%` (Modulo)-Operator – er gibt den Rest einer Division zurück. Wenn `x.index % 2 == 0`, ist der Rest `0`, was bedeutet, dass der Index gerade ist. Wenn `x.index % 2 != 0`, ist der Rest `1`, was bedeutet, dass der Index ungerade ist.

Hinweis

Um nur die ersten oder letzten Zeilen eines DataFrames anzuzeigen, verwende die Methoden `.head(n)` und `.tail(n)`, wobei `n` die Anzahl der anzuzeigenden Zeilen ist. Standardmäßig geben beide Methoden `5` Zeilen zurück, wenn `n` nicht angegeben ist.

Dieser Kurs enthält viele nützliche Funktionen für angehende Data Analysts. Sie lernen verschiedene Methoden zur Extraktion von Daten kennen und können sogar Bedingungen darauf anwenden. Anschließend werden Sie mit Methoden zur Gruppierung von Daten vertraut gemacht. Außerdem lernen Sie, wie man Daten vorverarbeitet. Jeder Abschnitt verfügt über einen eigenen Datensatz, sodass der Kurs spannend bleibt.

In diesem Abschnitt lernen Sie, wie Sie bestimmte Spalten anhand ihrer Titel oder Indizes ausgeben. Außerdem machen Sie sich mit den Methoden vertraut, mit denen Sie Zeilen anhand von Indizes auswählen können.

Hier lernen Sie, wie man Daten extrahiert, die bestimmte Bedingungen erfüllen. Außerdem lernen Sie, wie man diese kombiniert und sogar eigene Bedingungen erstellt.

In diesem Abschnitt erweitern Sie Ihr Wissen über das Festlegen verschiedener Datenbedingungen. Sie lernen, zu überprüfen, ob Ihre Daten in einer definierten Werteliste oder zwischen zwei Werten liegen. Sie erfahren außerdem, wie Sie die größten und kleinsten Werte finden.

Dieser Abschnitt ist einer der faszinierendsten des Kurses. Hier lernen Sie, wie Sie Daten auf verschiedene Arten gruppieren können. Dies wird Ihnen als Data Analyst helfen, Informationen über bestimmte Datengruppen zu ermitteln.

Dieser Abschnitt ist einer der wichtigsten für Datenanalysten, da es unmöglich ist, mit Daten zu arbeiten, wenn sie fehlende Werte oder ein falsches Format enthalten. Daher lernen Sie hier, wie man mit solchen ungeeigneten Werten umgeht.

Filtern von Zeilen mit Lambda-Funktionen

Lösung