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` erbjuder metoden `count()`, som räknar alla **icke-noll** celler (varken `None` eller `NaN`) för varje kolumn.
```python
df = pd.read_csv(file.csv)
number_of_cells = df.count()
```

För att hitta **antalet** icke-nollvärden i en specifik kolumn, använd följande syntax:
```python
df = pd.read_csv(file.csv)
number_of_cells = df['name of the column'].count()
```

`pandas` tillhandahåller också metoden `sum()`. Denna metod beräknar summan av värden för varje kolumn, men den fungerar endast med **numeriska** eller **boolean** kolumner.
```python
df = pd.read_csv(file.csv)
total = df.sum()
```

Eftersom metoden `isna()` returnerar en **boolean DataFrame**, kan du använda följande syntax för att beräkna antalet saknade värden för var och en av kolumnerna:

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

För att hitta summan av värden i en viss kolumn, använd följande syntax:
```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 är ett extremt användarvänligt bibliotek för dataanalys. Det är också utformat för att hantera stora datamängder, med hjälp av datastrukturer som DataFrame och Series. Detta gör det till ett ovärderligt verktyg för Data Science. I denna guide kommer du att bekanta dig med en rad statistiska funktioner, inklusive hur man hittar korrelationer, lägen, medianer och maximala och minimala värden inom en dataset. Du kommer också att lära dig hur man hanterar saknade värden och manipulerar specifika värden, samt hur man tar bort dem.

I det här avsnittet kommer vi att utforska grunderna i Series och DataFrame-strukturer. Du kommer också att lära dig om skillnaderna mellan dessa två typer av strukturer.

Data kan hämtas i olika format, såsom CSV, JSON, SQL, HTML och fler. Med Pandas är du inte begränsad till ett enda format — du kan arbeta med data från en mängd olika filtyper. I detta kapitel kommer vi specifikt att fokusera på CSV- och TXT-formaten.

Här kommer du att lära dig hur man bearbetar rådata genom att ta bort överflödig information och hantera nullvärden i en dataset.

Sum() och Count()

Lösning

Awesome!

Sum() och Count()

Lösning