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

O `pandas` oferece o prático método `mean()`, que calcula a **média** de todos os valores para cada coluna.
```python
df = pd.read_csv(file.csv)
mean_values = df.mean()
```

Também é possível usar o mesmo método para determinar o valor médio de uma coluna específica:
```python
df = pd.read_csv(file.csv)
mean_values = df['column_name'].mean()
```

O `pandas` também fornece o método `mode()`, que identifica o **valor que mais se repete** em cada coluna.
```python
df = pd.read_csv(file.csv)
mode_values = df.mode()
```

Para encontrar a moda de uma coluna específica, utiliza-se o mesmo método:
```python
df = pd.read_csv(file.csv)
mode_values = df['column_name'].mode()[0]
```

Utilizamos [0] após .mode() para extrair o primeiro valor caso existam múltiplas modas. Sem isso, o método retorna uma Série completa.

Nota

Outro método útil no `pandas` é o `describe()`.
```python
df = pd.read_csv(file.csv)
important_metrics = df.describe()
```

Este método fornece uma **visão geral de várias métricas** do conjunto de dados, incluindo:
- Número total de entradas;
- Valor médio ou média;
- Desvio padrão;
- Os valores mínimo e máximo;
- Os percentis 25º, 50º (mediana) e 75º.

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 é uma biblioteca extremamente amigável para análise de dados. Também é projetada para lidar com grandes conjuntos de dados, usando estruturas de dados como DataFrame e Series. Isso a torna uma ferramenta inestimável para Ciência de Dados. Neste guia, você se familiarizará com uma variedade de funções estatísticas, incluindo como encontrar correlações, modas, medianas e valores máximos e mínimos dentro de um conjunto de dados. Você também aprenderá a lidar com valores ausentes e manipular valores específicos, bem como como removê-los.

Nesta seção, exploraremos os fundamentos das estruturas Series e DataFrame. Você também aprenderá sobre as distinções entre esses dois tipos de estruturas.

Os dados podem ser obtidos em vários formatos, como CSV, JSON, SQL, HTML e mais. Com o Pandas, você não está limitado a um único formato — você pode trabalhar com dados em uma variedade de tipos de arquivos. Neste capítulo, vamos nos concentrar especificamente nos formatos CSV e TXT.

Aqui, você aprenderá a processar dados brutos removendo informações desnecessárias e gerenciando valores nulos em um conjunto de dados.

Descrevendo os Dados

Solução

Awesome!

Descrevendo os Dados

Solução

Awesome!