Summary  
This chapter covers how to use the pandas DataFrame, a two-dimensional labeled data structure that holds heterogeneous data, and demonstrates creating one from a dictionary and inspecting it via printing.

General domain of usage  
Data analysis

Yhteenvetona, `Series` on **yksidimensionaalinen** tietorakenne, joka muistuttaa listaa tai taulukon saraketta. Se sisältää **saman tyyppistä** dataa, ja jokainen alkio on merkitty **indeksillä**.

Vastaavasti `DataFrame` on monipuolinen **kaksidimensionaalinen** rakenne Pandas-kirjastossa, joka muistuttaa taulukkoa tai laskentataulukkoa riveineen ja sarakkeineen. Se voi sisältää **erityyppistä** dataa, ja jokainen sarake toimii `Series`-objektina. Kuten laskentataulukossa, `DataFrame` sisältää sekä indeksin että sarakeotsikot, mikä tekee siitä ihanteellisen suurten, rakenteellisten tietoaineistojen käsittelyyn.

Explore the concept of a DataFrame in Pandas. See how DataFrames organize data in rows and columns, making it easy to work with structured datasets. This video visually compares a DataFrame to a spreadsheet and demonstrates how to create a DataFrame from a dictionary using Python code. Gain a clear understanding of why DataFrames are a powerful tool for data analysis.

`DataFrame`-olion luomiseen tarvitaan `dictionary` yhdessä `.DataFrame()`-rakentajan kanssa.

import pandas as pd
people_data = {'name' : ['Ann', 'Alex', 'Kevin', 'Kate'], 
          'age' : [35, 12, 24, 45]}

people_df = pd.DataFrame(people_data)
print(people_df)

Jos haluat selvästi osoittaa, että muuttuja edustaa DataFramea, voit sisällyttää `df` muuttujan nimeen, kuten tässä esimerkissä (`people_df`).

Huomio

import unittest
import importlib
import pandas as pd


# Helper function to dynamically generate test names and assertions
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)


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


class TestUserCode(unittest.TestCase):

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

    def test_animals_is_dataframe(self):
        import user_code
        try:
            actual_value = user_code.animals
            condition = isinstance(actual_value, pd.DataFrame)
            failure_message = f"Expected `animals` to be a `DataFrame`, but got `{type(user_code.animals).__name__}`."

        except AttributeError:
            condition = False
            failure_message = "The `animals` variable is not declared."

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

    def test_animals_is_correct(self):
        import user_code

        expected_data = {
            'animal': ['Cat', 'Dog', 'Parrot', 'Cat', 'Parrot', 'Cat'],
            'name': ['Dolly', 'Abbey', 'Erin', 'Kelly', 'Taffy', 'Odie']
        }
        expected_df = pd.DataFrame(expected_data)

        variable = 'animals'
        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}` contains the correct data.",
            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 aineistosta. 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 muokkaaminen, rakenteen tutkiminen sekä olennaisten tietokäsittelytoimintojen hallinnan vahvistaminen.

Opi lataamaan ja hallitsemaan dataa CSV- ja TXT-tiedostoista. Saat käytännön kokemusta aineistojen tuonnista ja niiden valmistelusta jatkoanalyysia varten pandas-työkaluilla.

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

Dataframe

Ratkaisu