Summary
Demonstrates how to use DataFrame methods to preview and explore subsets of data—specifically, printing the first or last N rows with `head()` and `tail()`, and fetching random rows with `sample()`.

General domain of usage
Exploratory data analysis in tabular datasets.

Um die ersten Zeilen eines Datensatzes anzuzeigen, wird die Methode `head()` verwendet. Diese Methode akzeptiert ein **ganzzahliges** Argument, das angibt, wie viele Zeilen angezeigt werden sollen (standardmäßig werden die **ersten 5 Zeilen** angezeigt). Die ersten 10 Zeilen des Datensatzes anzeigen:

```python
df = pd.read_csv('file.csv')
# Extracting the first 10 rows
first_lines = df.head(10)
```

Um die **letzten Zeilen** eines `DataFrame` anzuzeigen, wird die Methode `tail()` verwendet. Sie funktioniert auf die gleiche Weise wie die Methode `head()`:

```python
df = pd.read_csv('file.csv')
# Extracting the last 10 rows
last_lines = df.tail(10)
```

Eine weitere nützliche Methode zur Erkundung von DataFrames ist `sample()`. Diese Methode wählt zufällige Einträge aus einem DataFrame aus. Standardmäßig wird **ein zufälliger Eintrag** zurückgegeben, sofern nicht anders angegeben.
```python
df = pd.read_csv('file.csv')
# Extracting 10 random rows
random_lines = df.sample(10)
```

import unittest
import importlib
import pandas as pd


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


def get_first_differing_row(expected_df, actual_df):
    expected_list = expected_df.astype(str).apply(tuple, axis=1)
    actual_list = actual_df.astype(str).apply(tuple, axis=1)

    for i, (row1, row2) in enumerate(zip(expected_list, actual_list)):
        if row1 != row2:
            return i, expected_df.iloc[i].values, actual_df.iloc[i].values

    if len(expected_df) > len(actual_df):
        return len(actual_df), expected_df.iloc[len(actual_df)].values, None
    else:
        return len(expected_df), None, actual_df.iloc[len(expected_df)].values


class TestUserCode(unittest.TestCase):

    def test_first_lines_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'first_lines'),
            "The `first_lines` variable is declared.",
            "Expected `first_lines` to be declared."
        )

    def test_first_lines_is_dataframe(self):
        import user_code

        try:
            condition = isinstance(user_code.first_lines, pd.DataFrame)
            failure_message = f"Expected `first_lines` to be a `DataFrame`, but got `{type(user_code.first_lines).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `first_lines` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `first_lines` is a `DataFrame`.",
            failure_message
        )

    def test_first_lines_has_correct_values(self):
        import user_code
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.head(10)

        variable = 'first_lines'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_last_lines_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'last_lines'),
            "The `last_lines` variable is declared.",
            "Expected `last_lines` to be declared."
        )

    def test_last_lines_is_dataframe(self):
        import user_code

        try:
            condition = isinstance(user_code.last_lines, pd.DataFrame)
            failure_message = f"Expected `last_lines` to be a `DataFrame`, but got `{type(user_code.last_lines).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `last_lines` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `last_lines` is a `DataFrame`.",
            failure_message
        )

    def test_last_lines_has_correct_values(self):
        import user_code
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.tail(15)

        variable = 'last_lines'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_random_rows_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'random_rows'),
            "The `random_rows` variable is declared.",
            "Expected `random_rows` to be declared."
        )

    def test_random_rows_is_dataframe(self):
        import user_code

        try:
            condition = isinstance(user_code.random_rows, pd.DataFrame)
            failure_message = f"Expected `random_rows` to be a `DataFrame`, but got `{type(user_code.random_rows).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `random_rows` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `random_rows` is a `DataFrame`.",
            failure_message
        )

    def test_random_rows_has_correct_values(self):
        import user_code
        import numpy as np
        np.random.seed(5)
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.sample(12)

        variable = 'random_rows'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )


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

test_main.py

Pandas ist eine äußerst benutzerfreundliche Bibliothek für die Datenanalyse. Sie ist zudem darauf ausgelegt, große Datensätze mithilfe von Datenstrukturen wie DataFrame und Series zu verarbeiten. Dadurch ist sie ein unverzichtbares Werkzeug für Data Science. In diesem Leitfaden lernen Sie eine Vielzahl statistischer Funktionen kennen, darunter das Ermitteln von Korrelationen, Modalwerten, Mediane sowie Maximal- und Minimalwerten innerhalb eines Datensatzes. Sie erfahren außerdem, wie Sie fehlende Werte behandeln und bestimmte Werte manipulieren sowie entfernen können.

Tauchen Sie in die Grundlagen der pandas-Bibliothek ein. Erstellen und bearbeiten Sie Series und DataFrames, untersuchen Sie deren Struktur und gewinnen Sie Sicherheit bei der Durchführung grundlegender Datenoperationen.

Erlernen des Ladens und Verwaltens von Daten aus CSV- und TXT-Dateien. Praktische Erfahrung im Importieren von Datensätzen und deren Vorbereitung für die weitere Analyse mit Pandas-Werkzeugen.

Erlernen Sie das effektive Erkunden, Bereinigen und Zusammenfassen von Daten. Verständnis für den Umgang mit fehlenden Werten, das Extrahieren von Erkenntnissen und das Durchführen grundlegender statistischer Operationen mit pandas.

Daten Anzeigen

Lösung

Daten Anzeigen

Lösung