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` proporciona el método `max()`, que devuelve el **valor más alto** de una columna especificada.

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

Para identificar el valor más alto de una columna específica, se puede utilizar el siguiente enfoque:
```python
df = pd.read_csv(file.csv)
max_values = df['column_name'].max()
```

De manera similar, `pandas` ofrece el método `min()` que obtiene el **valor más pequeño** de una columna determinada.
```python
df = pd.read_csv(file.csv)
min_value = df.min()
```

Para determinar el valor más pequeño de una columna en particular, se utiliza el mismo método:
```python
df = pd.read_csv(file.csv)
min_values = df['column_name'].min()
```

De manera similar, `pandas` ofrece el método `mean()` que obtiene el **valor promedio** de una columna dada.

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

Para determinar el valor promedio de una **columna en particular**, se utiliza el mismo método:

```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 es una biblioteca extremadamente fácil de usar para el análisis de datos. También está diseñada para manejar grandes conjuntos de datos, utilizando estructuras de datos como DataFrame y Series. Esto la convierte en una herramienta invaluable para la Ciencia de Datos. En esta guía, te familiarizarás con una variedad de funciones estadísticas, incluyendo cómo encontrar correlaciones, modas, medianas y valores máximos y mínimos dentro de un conjunto de datos. También aprenderás a manejar valores faltantes y manipular valores específicos, así como a eliminarlos.

En esta sección, exploraremos los fundamentos de las estructuras Series y DataFrame. También aprenderás sobre las diferencias entre estos dos tipos de estructuras.

Los datos pueden obtenerse en varios formatos, como CSV, JSON, SQL, HTML y más. Con Pandas, no estás limitado a un solo formato: puedes trabajar con datos de una multitud de tipos de archivos. En este capítulo, nos centraremos específicamente en los formatos CSV y TXT.

Aquí, aprenderás a procesar datos en bruto eliminando información innecesaria y gestionando valores nulos en un conjunto de datos.

Max(), Min() y Mean()

Solución

Awesome!

Max(), Min() y Mean()

Solución

Awesome!