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` offre il comodo metodo `mean()` che calcola la **media** di tutti i valori per ciascuna colonna.
```python
df = pd.read_csv(file.csv)
mean_values = df.mean()
```

È possibile utilizzare lo stesso metodo per determinare il valore medio di una colonna specifica:
```python
df = pd.read_csv(file.csv)
mean_values = df['column_name'].mean()
```

`pandas` fornisce anche il metodo `mode()`, che identifica il **valore che si presenta più frequentemente** in ciascuna colonna.
```python
df = pd.read_csv(file.csv)
mode_values = df.mode()
```

Per trovare la moda di una particolare colonna, si utilizza lo stesso metodo:
```python
df = pd.read_csv(file.csv)
mode_values = df['column_name'].mode()[0]
```

Utilizzare `[0]` dopo `.mode()` per estrarre il primo valore se esistono più mode. Senza questa notazione, il metodo restituisce un'intera `Series`.


Nota

Un altro metodo utile in `pandas` è `describe()`.
```python
df = pd.read_csv(file.csv)
important_metrics = df.describe()
```

Questo metodo fornisce una **panoramica di varie metriche** dal dataset, tra cui:
- Numero totale di voci;
- Valore medio o media;
- Deviazione standard;
- I valori minimo e massimo;
- Il 25°, 50° (mediana) e 75° percentile.

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 è una libreria estremamente intuitiva per l'analisi dei dati. È inoltre progettata per gestire grandi set di dati, utilizzando strutture dati come DataFrame e Series. Questo la rende uno strumento prezioso per la Data Science. In questa guida, verrà presentata una gamma di funzioni statistiche, tra cui la ricerca di correlazioni, moda, mediana, valori massimi e minimi all'interno di un set di dati. Verranno inoltre illustrate le modalità di gestione dei valori mancanti e la manipolazione o rimozione di valori specifici.

Approfondimento sui fondamenti della libreria pandas. Creazione e manipolazione di Series e DataFrame, esplorazione della loro struttura e sviluppo di sicurezza nell'esecuzione delle principali operazioni sui dati.

Apprendere come caricare e gestire dati da file CSV e TXT. Acquisire esperienza pratica nell'importazione di dataset e nella loro preparazione per ulteriori analisi utilizzando gli strumenti di pandas.

Apprendere come esplorare, pulire e sintetizzare i dati in modo efficace. Comprendere la gestione dei valori mancanti, l'estrazione di informazioni e l'esecuzione di operazioni statistiche di base con pandas.

Descrivere i Dati

Soluzione

Awesome!

Descrivere i Dati

Soluzione