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

To recap, a `Series` is a **one-dimensional** data structure, similar to a list or a column in a spreadsheet. It holds data of the **same type**, with each element labeled by an **index**.

In contrast, a `DataFrame` is a versatile **two-dimensional** structure in Pandas, similar to a table or spreadsheet, with rows and columns. It can hold data of **different types**, with each column functioning as a `Series`. Like a spreadsheet, a `DataFrame` includes both an index and column labels, making it ideal for handling large, structured datasets.

To create a `DataFrame` object, you'll need to use a `dictionary` in conjunction with the `.DataFrame()` constructor.

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)

If you want to explicitly indicate that the variable represents a DataFrame, you can include `df` in the variable name, as shown in this example (`people_df`).

Note

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 is an extremely user-friendly library for data analysis. It's also designed to handle large datasets, using data structures like DataFrame and Series. This makes it an invaluable tool for Data Science. In this guide, you'll get acquainted with a range of statistical functions, including how to find correlations, modes, medians, and maximum and minimum values within a dataset. You'll also learn how to handle missing values and manipulate specific values, as well as how to remove them.

Dive into the fundamentals of the pandas library. Learn to create and manipulate Series and DataFrames, explore their structure, and build confidence in performing essential data operations.

Master how to load and manage data from CSV and TXT files. Gain practical experience importing datasets and preparing them for further analysis using pandas tools.

Learn to explore, clean, and summarize data effectively. Understand how to handle missing values, extract insights, and perform basic statistical operations with pandas.

DataFrame

Solution

Awesome!

DataFrame

Solution