Summary
This chapter explains how to detect null or missing values in tabular data structures by using methods that return boolean masks indicating where entries are absent.

General domain of usage
data analysis

DataFrame-taulukoissa esiintyy usein **puuttuvia arvoja**, jotka esitetään muodossa `None` tai `NaN`. DataFramejen kanssa työskennellessä on tärkeää tunnistaa nämä puuttuvat arvot, sillä ne voivat vääristää laskelmia, johtaa epätarkkoihin analyyseihin ja heikentää tulosten luotettavuutta.

Puuttuvien arvojen käsittely varmistaa **datan eheyden** ja parantaa tehtävien, kuten **tilastollisen analyysin** ja **koneoppimisen**, suorituskykyä. Tätä varten pandas tarjoaa erityisiä menetelmiä.

Ensimmäinen näistä on `isna()`, joka palauttaa **totuusarvoisen DataFrame-taulukon**. Tässä yhteydessä arvo `True` ilmaisee puuttuvan arvon DataFramessa, kun taas `False` tarkoittaa, että arvo on olemassa.

Selkeyden vuoksi tätä menetelmää sovelletaan `animals`-DataFrameen. `isna()`-metodi palauttaa `DataFrame`-taulukon, jossa on `True`/`False`-arvoja; jokainen `True` osoittaa puuttuvan arvon `animals`-DataFramessa.


import pandas as pd
import numpy as np

animals_data = {'animal': [np.nan, 'Dog', np.nan, 'Cat','Parrot', None],
'name': ['Dolly', None, 'Erin', 'Kelly', None, 'Odie']}
animals = pd.DataFrame(animals_data)
# Find missing values
missing_values = animals.isna()
print(missing_values)

Toinen menetelmä on `isnull()`. Se toimii samalla tavalla kuin edellinen, eikä niiden välillä ole havaittavaa eroa.

import unittest
import importlib
import pandas as pd


def get_first_differing_row(expected_df, actual_df):
    expected_list = expected_df.astype(str).apply(tuple, axis=1)
    actual_list = actual_df.astype(str).apply(tuple, axis=1)

    for i, (row1, row2) in enumerate(zip(expected_list, actual_list)):
        if row1 != row2:
            return i, expected_df.iloc[i].values, actual_df.iloc[i].values

    if len(expected_df) > len(actual_df):
        return len(actual_df), expected_df.iloc[len(actual_df)].values, None
    else:
        return len(expected_df), None, actual_df.iloc[len(expected_df)].values


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_missing_values_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'missing_values'),
            "The `missing_values` variable is declared.",
            "Expected `missing_values` to be declared."
        )

    def test_missing_values_is_dataframe(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "The variable `missing_values` is a `DataFrame`.",
            failure_message
        )

    def test_missing_values_has_correct_values(self):
        import user_code
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine_with_nan.csv')
        expected_df = wine_data.isnull()

        variable = 'missing_values'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` correctly identifies missing values.",
            failure_message
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Pandas on erittäin käyttäjäystävällinen kirjasto data-analyysiin. Se on myös suunniteltu käsittelemään suuria tietoaineistoja hyödyntäen tietorakenteita kuten DataFrame ja Series. Tämä tekee siitä korvaamattoman työkalun Data Science -alalla. Tässä oppaassa tutustut erilaisiin tilastollisiin funktioihin, kuten korrelaatioiden, moodien, mediaanien sekä suurimpien ja pienimpien arvojen etsimiseen tietoaineistosta. Opit myös käsittelemään puuttuvia arvoja ja muokkaamaan sekä poistamaan yksittäisiä arvoja.

Pandas-kirjaston perusteiden tarkastelu. Series- ja DataFrame-olioiden luominen ja käsittely, rakenteen tutkiminen sekä varmuuden kehittäminen olennaisten tietoaineistojen käsittelytoimintojen suorittamisessa.

Opi hallitsemaan tiedon lataamista ja käsittelyä CSV- ja TXT-tiedostoista. Saat käytännön kokemusta aineistojen tuonnista ja valmistelusta jatkoanalyysiä varten pandas-työkaluilla.

Opi tutkimaan, puhdistamaan ja tiivistämään dataa tehokkaasti. Ymmärrä, kuinka käsitellä puuttuvia arvoja, löytää oivalluksia ja suorittaa perus tilastollisia operaatioita pandas-kirjastolla.

Puuttuvien Arvojen Löytäminen

Ratkaisu