Summary  
This chapter covers using Pandas’ max(), min(), and mean() methods to compute the highest, lowest, and average values of numeric columns or entire data frames.

General domain of usage  
Exploratory data analysis

Explore how to use the `max()`, `min()`, and `mean()` methods in pandas to analyze your data. This video walks you through each method step by step, using clear examples with real DataFrames. You'll see how to quickly find the highest, lowest, and average values in your data, learn the difference between applying these methods to entire DataFrames versus specific columns, and understand how these tools help summarize and interpret your datasets efficiently. By the end, you'll be able to confidently use these essential pandas methods in your own projects.

`pandas` stellt die Methode `max()` bereit, die den **höchsten Wert** aus einer angegebenen Spalte zurückgibt.

```python
df = pd.read_csv(file.csv)
max_value = df.max()
```

Um den höchsten Wert einer bestimmten Spalte zu ermitteln, kann folgende Vorgehensweise verwendet werden:
```python
df = pd.read_csv(file.csv)
max_values = df['column_name'].max()
```

Ebenso bietet `pandas` die Methode `min()` an, die den **kleinsten Wert** aus einer angegebenen Spalte liefert.
```python
df = pd.read_csv(file.csv)
min_value = df.min()
```

Um den kleinsten Wert einer bestimmten Spalte zu ermitteln, wird die gleiche Methode verwendet:
```python
df = pd.read_csv(file.csv)
min_values = df['column_name'].min()
```

Ebenso bietet `pandas` die Methode `mean()` an, die den **Durchschnittswert** einer angegebenen Spalte ermittelt.

```python
df = pd.read_csv(file.csv)
average_value = df.mean()
```

Um den Durchschnittswert einer **bestimmten Spalte** zu ermitteln, wird die gleiche Methode verwendet:

```python
df = pd.read_csv(file.csv)
average_value = df['column_name'].mean()
```

import unittest
import importlib


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)


class TestUserCode(unittest.TestCase):

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

    def test_highest_price_is_correct(self):
        import user_code
        expected_value = max([12500, 16500, 16800, 17300, 16500])

        try:
            actual_value = user_code.highest_price
            condition = actual_value == expected_value
            failure_message = f"Expected `highest_price` to be `{expected_value}`, but got `{actual_value}`."
        except AttributeError:
            condition = False
            failure_message = "The `highest_price` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"The `highest_price` is `{expected_value}`.",
            failure_message
        )

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

    def test_lowest_price_is_correct(self):
        import user_code
        expected_value = min([12500, 16500, 16800, 17300, 16500])

        try:
            actual_value = user_code.lowest_price
            condition = actual_value == expected_value
            failure_message = f"Expected `lowest_price` to be `{expected_value}`, but got `{actual_value}`."
        except AttributeError:
            condition = False
            failure_message = "The `lowest_price` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"`lowest_price` has correct value.",
            failure_message
        )

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

    def test_average_price_is_correct(self):
        import user_code
        expected_value = sum([12500, 16500, 16800, 17300, 16500]) / 5

        try:
            actual_value = user_code.average_price
            condition = actual_value == expected_value
            failure_message = f"Expected `average_price` to be `{expected_value}`, but got `{actual_value}`."
        except AttributeError:
            condition = False
            failure_message = "The `average_price` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "`average_price` has correct value.",
            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 verschiedene statistische Funktionen kennen, einschließlich der Ermittlung von Korrelationen, Modalwerten, Mediane sowie maximalen und minimalen Werten innerhalb eines Datensatzes. Sie erfahren außerdem, wie fehlende Werte behandelt und spezifische Werte manipuliert sowie entfernt werden können.

Tauchen Sie ein in die Grundlagen der pandas-Bibliothek. Erstellung und Manipulation von Series und DataFrames, Untersuchung ihrer Struktur sowie Aufbau von Sicherheit bei der Durchführung grundlegender Datenoperationen.

Erlernen Sie das Laden und Verwalten von Daten aus CSV- und TXT-Dateien. Sammeln Sie praktische Erfahrungen beim Importieren von Datensätzen und deren Vorbereitung für die weitere Analyse mit den Werkzeugen von pandas.

Erlernen Sie das effektive Erkunden, Bereinigen und Zusammenfassen von Daten. Verstehen Sie den Umgang mit fehlenden Werten, das Gewinnen von Erkenntnissen und das Durchführen grundlegender statistischer Operationen mit pandas.

Max(), Min() und Mean()

Lösung