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` biedt de methode `count()`, waarmee alle **niet-nul** cellen (noch `None` noch `NaN`) per kolom worden geteld.
```python
df = pd.read_csv(file.csv)
number_of_cells = df.count()
```

Om het **aantal** niet-nul waarden in een specifieke kolom te bepalen, gebruik de volgende syntaxis:
```python
df = pd.read_csv(file.csv)
number_of_cells = df['name of the column'].count()
```

`pandas` biedt ook de methode `sum()`. Deze methode berekent de som van de waarden per kolom, maar werkt alleen met **numerieke** of **booleaanse** kolommen.
```python
df = pd.read_csv(file.csv)
total = df.sum()
```

Aangezien de methode `isna()` een **booleaanse DataFrame** retourneert, kun je de volgende syntaxis gebruiken om het aantal ontbrekende waarden per kolom te berekenen:

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

Om de som van waarden in een specifieke kolom te berekenen, gebruik de volgende syntaxis:
```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 is een uiterst gebruiksvriendelijke bibliotheek voor data-analyse. Het is ook ontworpen om grote datasets te verwerken, met behulp van datastructuren zoals DataFrame en Series. Dit maakt het een onmisbaar hulpmiddel voor Data Science. In deze gids maak je kennis met diverse statistische functies, waaronder het vinden van correlaties, modi, medianen en maximale en minimale waarden binnen een dataset. Je leert ook hoe je omgaat met ontbrekende waarden en specifieke waarden kunt manipuleren of verwijderen.

Verdiep je in de basisprincipes van de pandas-bibliotheek. Leer het aanmaken en manipuleren van Series en DataFrames, onderzoek hun structuur en ontwikkel vertrouwen in het uitvoeren van essentiële data-operaties.

Beheers het laden en beheren van gegevens uit CSV- en TXT-bestanden. Praktische ervaring opdoen met het importeren van datasets en het voorbereiden ervan voor verdere analyse met behulp van pandas-tools.

Leer gegevens effectief te verkennen, opschonen en samenvatten. Begrijp hoe ontbrekende waarden te behandelen, inzichten te verkrijgen en basisstatistische bewerkingen uit te voeren met pandas.

Sum() en Count()

Oplossing

Awesome!

Sum() en Count()

Oplossing