Summary  
This chapter covers using pandas DataFrame aggregation methods: `count()` to count non-null values per column (or in a specific column) and `sum()` to total numeric or boolean columns (including counting missing values via `isna().sum()`).  

General domain of usage  
Data analysis

`pandas` bietet die Methode `count()`, die alle **nicht-null** Zellen (weder `None` noch `NaN`) für jede Spalte zählt.
```python
df = pd.read_csv(file.csv)
number_of_cells = df.count()
```

Um die **Anzahl** der nicht-null Werte in einer bestimmten Spalte zu ermitteln, folgende Syntax verwenden:
```python
df = pd.read_csv(file.csv)
number_of_cells = df['name of the column'].count()
```

`pandas` stellt außerdem die Methode `sum()` bereit. Diese Methode berechnet die Summe der Werte für jede Spalte, funktioniert jedoch nur mit **numerischen** oder **booleschen** Spalten.
```python
df = pd.read_csv(file.csv)
total = df.sum()
```

Da die Methode `isna()` ein **boolesches DataFrame** zurückgibt, kann folgende Syntax verwendet werden, um die Anzahl der fehlenden Werte für jede Spalte zu berechnen:

```python
missing_values_count = df.isna().sum()
```

Um die Summe der Werte in einer bestimmten Spalte zu berechnen, folgende Syntax verwenden:
```python
df = pd.read_csv(file.csv)
total = df['name of the column'].sum()
```

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)


class TestUserCode(unittest.TestCase):

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

    def test_number_of_cells_is_correct(self):
        import user_code
        cars_data = {'model': [None, 'audi A6', 'audi A4', None, 'audi A1'],
                     'year': [2017, 2016, 2017, None, 2016],
                     'fueltype': [None, 'diesel', 'diesel', 'petrol', 'petrol'],
                     'price': [12500, 16500, 16800, 17300, 16500]}
        audi_cars = pd.DataFrame(cars_data)
        expected_value = audi_cars.count()

        try:
            condition = user_code.number_of_cells.equals(expected_value)
            failure_message = f"Expected `number_of_cells` to be `{expected_value}`, but got `{user_code.number_of_cells}`."
        except AttributeError:
            condition = False
            if not getattr(user_code, 'number_of_cells', None):
                failure_message = "The `number_of_cells` variable is not declared."
            else:
                failure_message = "`number_of_cells` is not a `Series`."

        _dynamic_test(
            self,
            condition,
            f"`number_of_cells` contains the correct values.",
            failure_message
        )

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

    def test_total_price_is_correct(self):
        import user_code
        cars_data = {'model': [None, 'audi A6', 'audi A4', None, 'audi A1'],
                     'year': [2017, 2016, 2017, None, 2016],
                     'fueltype': [None, 'diesel', 'diesel', 'petrol', 'petrol'],
                     'price': [12500, 16500, 16800, 17300, 16500]}
        audi_cars = pd.DataFrame(cars_data)
        expected_value = audi_cars['price'].sum()

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

        _dynamic_test(
            self,
            condition,
            f"`total_price` is correct.",
            failure_message
        )

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

    def test_null_count_is_series(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "The variable `null_count` is a `Series`.",
            failure_message
        )

    def test_null_count_is_correct(self):
        import user_code
        cars_data = {'model': [None, 'audi A6', 'audi A4', None, 'audi A1'],
                     'year': [2017, 2016, 2017, None, 2016],
                     'fueltype': [None, 'diesel', 'diesel', 'petrol', 'petrol'],
                     'price': [12500, 16500, 16800, 17300, 16500]}
        audi_cars = pd.DataFrame(cars_data)
        expected_value = audi_cars.isna().sum()

        variable = 'null_count'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, pd.Series):
            condition = actual_value.equals(expected_value)
            if actual_value.empty:
                failure_message = f"`{variable}` is empty."
            else:
                failure_message = f"Expected `{variable}` to contain `{expected_value.values}`, but got `{actual_value.values}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `Series`."

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

        _dynamic_test(
            self,
            condition,
            f"`null_count` contains the correct values.",
            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 Maximal- und Minimalwerten innerhalb eines Datensatzes. Außerdem erfahren Sie, wie fehlende Werte behandelt und spezifische Werte manipuliert oder entfernt werden können.

Einführung in die Grundlagen der pandas-Bibliothek. Erstellung und Bearbeitung 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 Pandas-Werkzeugen.

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

Sum() und Count()

Lösung

Awesome!

Sum() und Count()

Lösung