Summary  
This chapter covers using library methods to compute descriptive statistics—mean, mode, and summary metrics—on tabular data.

General domain of usage  
Data analysis

`pandas` offers the handy `mean()` method that calculates the **average** of all values for each column.
```python
df = pd.read_csv(file.csv)
mean_values = df.mean()
```

You can also the same method to determine the average value for a specific column:
```python
df = pd.read_csv(file.csv)
mean_values = df['column_name'].mean()
```

`pandas` also provides the `mode()` method, which identifies the **most frequently occurring value** in each column.
```python
df = pd.read_csv(file.csv)
mode_values = df.mode()
```

To find the mode for a particular column, the same method is used:
```python
df = pd.read_csv(file.csv)
mode_values = df['column_name'].mode()[0]
```

Use `[0]` after `.mode()` to extract the first value if multiple modes exist. Without it, the method returns an entire `Series`.


Note

Another useful method in `pandas` is `describe()`.
```python
df = pd.read_csv(file.csv)
important_metrics = df.describe()
```

This method provides an **overview of various metrics** from the dataset, including:
- Total number of entries;
- Mean or average value;
- Standard deviation;
- The minimum and maximum values;
- The 25th, 50th (median), and 75th percentiles.

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)


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

    def test_residual_sugar_mean_is_correct(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.csv')
        expected_value = wine_data['residual sugar'].mean()

        try:
            condition = user_code.residual_sugar_mean == expected_value
            failure_message = f"Expected `residual_sugar_mean` to be `{expected_value}`, but got `{user_code.residual_sugar_mean}`."
        except AttributeError:
            condition = False
            failure_message = "The `residual_sugar_mean` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"`residual_sugar_mean` contains the correct value.",
            failure_message
        )

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

    def test_fixed_acidity_mode_is_correct(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.csv')
        expected_value = wine_data['fixed acidity'].mode()[0]

        try:
            condition = user_code.fixed_acidity_mode == expected_value
            failure_message = f"Expected `fixed_acidity_mode` to be `{expected_value}`, but got `{user_code.fixed_acidity_mode}`."
        except AttributeError:
            condition = False
            failure_message = "The `fixed_acidity_mode` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"`fixed_acidity_mode` contains the correct value.",
            failure_message
        )

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

    def test_described_data_is_dataframe(self):
        import user_code

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

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

    def test_described_data_is_correct(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.csv')
        expected_df = wine_data.describe()

        variable = 'described_data'
        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 statistical summary.",
            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.

Describing the Data

解答