Summary  
This chapter covers using built-in methods to compute the maximum, minimum, and arithmetic mean of values in a data structure column.  

General domain of usage  
Tabular data analysis and descriptive statistics

`pandas` propose la méthode `max()`, qui retourne la **valeur la plus élevée** d'une colonne spécifiée.

```python
df = pd.read_csv(file.csv)
max_value = df.max()
```

Pour identifier la valeur la plus élevée d'une colonne spécifique, cette approche peut être utilisée :
```python
df = pd.read_csv(file.csv)
max_values = df['column_name'].max()
```

De même, `pandas` offre la méthode `min()` qui récupère la **valeur la plus petite** d'une colonne donnée.
```python
df = pd.read_csv(file.csv)
min_value = df.min()
```

Pour déterminer la plus petite valeur d'une colonne particulière, la même méthode est utilisée :
```python
df = pd.read_csv(file.csv)
min_values = df['column_name'].min()
```

De même, `pandas` propose la méthode `mean()` qui récupère la **valeur moyenne** d'une colonne donnée.

```python
df = pd.read_csv(file.csv)
average_value = df.mean()
```

Pour déterminer la valeur moyenne d'une **colonne particulière**, la même méthode est utilisée :

```python
df = pd.read_csv(file.csv)
average_value = df['column_name'].mean()
```

import unittest
import importlib


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)


class TestUserCode(unittest.TestCase):

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

    def test_highest_price_is_correct(self):
        import user_code
        expected_value = max([12500, 16500, 16800, 17300, 16500])

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

        _dynamic_test(
            self,
            condition,
            f"The `highest_price` is `{expected_value}`.",
            failure_message
        )

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

    def test_lowest_price_is_correct(self):
        import user_code
        expected_value = min([12500, 16500, 16800, 17300, 16500])

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

        _dynamic_test(
            self,
            condition,
            f"`lowest_price` has correct value.",
            failure_message
        )

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

    def test_average_price_is_correct(self):
        import user_code
        expected_value = sum([12500, 16500, 16800, 17300, 16500]) / 5

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

        _dynamic_test(
            self,
            condition,
            "`average_price` has correct value.",
            failure_message
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Pandas est une bibliothèque extrêmement conviviale pour l'analyse de données. Elle est également conçue pour gérer de grands ensembles de données, en utilisant des structures telles que DataFrame et Series. Cela en fait un outil précieux pour la Data Science. Dans ce guide, vous découvrirez une gamme de fonctions statistiques, notamment comment trouver les corrélations, les modes, les médianes, ainsi que les valeurs maximales et minimales au sein d'un ensemble de données. Vous apprendrez également à gérer les valeurs manquantes et à manipuler des valeurs spécifiques, ainsi qu'à les supprimer.

Découvrez les bases de la bibliothèque pandas. Création et manipulation de Series et DataFrames, exploration de leur structure, acquisition des compétences nécessaires pour effectuer les opérations de données essentielles.

Maîtrise du chargement et de la gestion des données à partir de fichiers CSV et TXT. Acquisition d'une expérience pratique dans l'importation de jeux de données et leur préparation pour une analyse ultérieure à l'aide des outils pandas.

Apprenez à explorer, nettoyer et résumer les données de manière efficace. Comprendre la gestion des valeurs manquantes, l'extraction d'informations et l'exécution d'opérations statistiques de base avec pandas.

Max(), Min() et Mean()

Solution

Max(), Min() et Mean()

Solution