Summary  
Introduces the Pandas DataFrame as a two-dimensional, heterogeneous data structure composed of labeled Series and shows how to create one from a dictionary using the pd.DataFrame constructor.

General domain of usage  
Data analysis and manipulation

Sammanfattningsvis är en `Series` en **endimensionell** datastruktur, liknande en lista eller en kolumn i ett kalkylblad. Den innehåller data av **samma typ**, där varje element är märkt med ett **index**.

Till skillnad från detta är en `DataFrame` en mångsidig **tvådimensionell** struktur i Pandas, liknande en tabell eller ett kalkylblad, med rader och kolumner. Den kan innehålla data av **olika typer**, där varje kolumn fungerar som en `Series`. Precis som ett kalkylblad har en `DataFrame` både ett index och kolumnetiketter, vilket gör den idealisk för att hantera stora, strukturerade datamängder.

För att skapa ett `DataFrame`-objekt behöver du använda en `dictionary` tillsammans med konstruktorn `.DataFrame()`.

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)

Om du vill tydligt ange att variabeln representerar en DataFrame kan du inkludera `df` i variabelnamnet, som visas i detta exempel (`people_df`).

Observera

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 är ett mycket 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 inom Data Science. I denna guide får du bekanta dig med olika statistiska funktioner, inklusive hur man hittar korrelationer, typvärden, medianer samt maximala och minimala värden i en datamängd. Du lär dig även hur man hanterar saknade värden och manipulerar specifika värden, samt hur man tar bort dem.

Fördjupa dig i grunderna för pandas-biblioteket. Skapa och manipulera Series och DataFrames, utforska deras struktur och stärk din förmåga att utföra grundläggande dataoperationer.

Bemästra hur du läser in och hanterar data från CSV- och TXT-filer. Få praktisk erfarenhet av att importera dataset och förbereda dem för vidare analys med hjälp av pandas-verktyg.

Lär dig att utforska, rensa och sammanfatta data på ett effektivt sätt. Förstå hur man hanterar saknade värden, extraherar insikter och utför grundläggande statistiska operationer med pandas.

DataFrame

Lösning

Awesome!

DataFrame

Lösning