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 **plus petite valeur** 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 de données comme DataFrame et Series. Cela en fait un outil inestimable pour la science des données. Dans ce guide, vous vous familiariserez avec une gamme de fonctions statistiques, y compris comment trouver des corrélations, des modes, des médianes, et des 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.

Dans cette section, nous explorerons les fondamentaux des structures Series et DataFrame. Vous apprendrez également les distinctions entre ces deux types de structures.

Les données peuvent être obtenues dans divers formats, tels que CSV, JSON, SQL, HTML, et plus encore. Avec Pandas, vous n'êtes pas limité à un seul format — vous pouvez travailler avec des données provenant de nombreux types de fichiers. Dans ce chapitre, nous nous concentrerons spécifiquement sur les formats CSV et TXT.

Ici, vous apprendrez à traiter les données brutes en supprimant les informations superflues et en gérant les valeurs nulles dans un ensemble de données.

Max(), Min() et Mean()

Solution

Awesome!

Max(), Min() et Mean()

Solution

Awesome!