Summary
This chapter demonstrates how to use a lambda function with DataFrame.iloc to filter rows based on index conditions.

General domain of usage
Data analysis

Ibland behöver vi ställa vissa villkor på indexen. I dessa fall behöver du använda en `lambda`-funktion inuti `iloc[]`.

Låt oss undersöka vad vi kan göra med `lambda`:
```python
data.iloc[lambda x: x.index < 5]
```
Denna kod returnerar de första fem raderna i datasettet, det vill säga raderna med index `0`, `1`, `2`, `3` och `4`.
- `lambda x` – `x` är argumentet vi arbetar med (posten i datasettet);
- `x.index` – extraherar endast värdena för radindexen;
- `x.index < 5` – villkoret enligt vilket vi hämtar data. Här hämtas endast rader med index mindre än `5`.

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

Denna kurs innehåller många användbara funktioner för en framtida dataanalytiker. Du kommer att lära dig olika metoder för att extrahera data och även sätta villkor på den. Därefter kommer du att bli bekant med metoder för att gruppera data. Du kommer också att lära dig hur man förbehandlar data. Varje avsnitt har sin egen datamängd, vilket gör kursen engagerande.

Detta avsnitt lär dig hur du kan visa specifika kolumner med hjälp av deras titlar eller index. Du kommer även att bekanta dig med metoder för att välja rader baserat på index.

Här kommer du att lära dig hur du extraherar data som uppfyller specifika villkor. Du kommer även att lära dig hur du kombinerar dessa och till och med skapa egna.

I det här avsnittet kommer du att fördjupa dina kunskaper om att ange olika datavillkor. Du kommer att lära dig att kontrollera om dina data finns i en definierad lista av värden eller mellan två värden. Du kommer även att lära dig hur du hittar de största och minsta värdena.

Detta avsnitt är ett av de mest fascinerande i kursen. Här får du lära dig hur man grupperar data på olika sätt. Det hjälper dig att arbeta som dataanalytiker för att ta fram information om specifika datagrupper.

Detta avsnitt är ett av de mest betydelsefulla för en dataanalytiker eftersom det blir omöjligt att arbeta med data om den innehåller saknade värden eller felaktigt format. Här lär du dig hur du hanterar sådana olämpliga värden.

Att Bekanta Sig Med Lambda-Funktioner

Lösning