Summary  
This chapter covers using built-in methods to compute the maximum, minimum, and arithmetic mean of values in a data structure column.  

General domain of usage  
Tabular data analysis and descriptive statistics

`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()`, die den **kleinsten Wert** aus einer angegebenen Spalte ermittelt.
```python
df = pd.read_csv(file.csv)
min_value = df.min()
```

Um den kleinsten Wert für eine bestimmte 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 für eine **bestimmte Spalte** zu berechnen, 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 auch darauf ausgelegt, große Datensätze zu verarbeiten, indem sie Datenstrukturen wie DataFrame und Series verwendet. Dies macht sie zu einem unverzichtbaren Werkzeug für Data Science. In diesem Leitfaden lernen Sie eine Reihe von statistischen Funktionen kennen, einschließlich der Berechnung von Korrelationen, Modi, Mediane sowie maximalen und minimalen Werten innerhalb eines Datensatzes. Sie lernen auch, wie man mit fehlenden Werten umgeht und spezifische Werte manipuliert sowie entfernt.

In diesem Abschnitt werden wir die Grundlagen der Series- und DataFrame-Strukturen erkunden. Sie werden auch die Unterschiede zwischen diesen beiden Strukturtypen kennenlernen.

Daten können in verschiedenen Formaten vorliegen, wie CSV, JSON, SQL, HTML und mehr. Mit Pandas sind Sie nicht auf ein einzelnes Format beschränkt – Sie können mit Daten aus einer Vielzahl von Dateitypen arbeiten. In diesem Kapitel konzentrieren wir uns speziell auf die Formate CSV und TXT.

Hier lernen Sie, wie Sie Rohdaten verarbeiten, indem Sie überflüssige Informationen entfernen und Nullwerte in einem Datensatz verwalten.

Max(), Min() und Mean()

Lösung

Awesome!

Max(), Min() und Mean()

Lösung

Awesome!