`pandas` tarjoaa `count()`-metodin, joka laskee kaikki **ei-null** solut (ei `None` eikä `NaN`) jokaiselle sarakkeelle.
```python
df = pd.read_csv(file.csv)
number_of_cells = df.count()
```

Löytääksesi tietyn sarakkeen **ei-null** arvojen määrän, käytä seuraavaa syntaksia:
```python
df = pd.read_csv(file.csv)
number_of_cells = df['name of the column'].count()
```

`pandas` tarjoaa myös `sum()`-metodin. Tämä metodi laskee arvojen summan jokaiselle sarakkeelle, mutta se toimii vain **numeerisilla** tai **boolean** sarakkeilla.
```python
df = pd.read_csv(file.csv)
total = df.sum()
```

Koska `isna()`-metodi palauttaa **boolean DataFrame**:n, voit käyttää seuraavaa syntaksia laskeaksesi puuttuvien arvojen määrän jokaiselle sarakkeelle:

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

Löytääksesi tietyn sarakkeen arvojen summan, käytä seuraavaa syntaksia:
```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 on erittäin käyttäjäystävällinen kirjasto datan analysointiin. Se on myös suunniteltu käsittelemään suuria tietoaineistoja, käyttäen tietorakenteita kuten DataFrame ja Series. Tämä tekee siitä korvaamattoman työkalun Data Scienceen. Tässä oppaassa tutustut erilaisiin tilastollisiin funktioihin, mukaan lukien kuinka löytää korrelaatioita, moodit, mediaanit sekä maksimi- ja minimiarvot tietoaineistossa. Opit myös käsittelemään puuttuvia arvoja ja manipuloimaan tiettyjä arvoja sekä poistamaan niitä.

Tässä osiossa tutustumme Series- ja DataFrame-rakenteiden perusteisiin. Opit myös näiden kahden rakenteen välisistä eroista.

Dataa voi olla saatavilla eri muodoissa, kuten CSV, JSON, SQL, HTML ja monia muita. Pandasin avulla et ole rajoittunut yhteen muotoon — voit työskennellä datan kanssa monissa eri tiedostotyypeissä. Tässä luvussa keskitymme erityisesti CSV- ja TXT-muotoihin.

Tässä opit käsittelemään raakadataa poistamalla ylimääräistä tietoa ja hallitsemalla puuttuvia arvoja tietojoukossa.

Sum() ja Count()

Ratkaisu

Sum() ja Count()

Ratkaisu